From ac1465a11e97aa72fe8aef3d89f12df388cd8d72 Mon Sep 17 00:00:00 2001 From: Jonathan Berthias Date: Tue, 30 Dec 2025 17:38:31 +0100 Subject: [PATCH 01/15] Run `stubtest` to check stubs are complete (#1141) * Fix mypy errors * Generate stubtest allowlist * Split expected errors out of todo * Move all stub-related files to stubs folder * Add workflow to check stubs * Simplify file names * Don't run ruff on everything * Revert error added for testing * Clarify requirements for stubtest * Run mypy in CI --- .github/workflows/stubs.yml | 71 + src/pyscipopt/__init__.py | 2 +- src/pyscipopt/recipes/getLocalConss.py | 2 +- src/pyscipopt/scip.pyi | 22 +- stubs/allowlist | 3 + stubs/test.sh | 10 + stubs/todo | 3680 ++++++++++++++++++++++++ 7 files changed, 3777 insertions(+), 13 deletions(-) create mode 100644 .github/workflows/stubs.yml create mode 100644 stubs/allowlist create mode 100755 stubs/test.sh create mode 100644 stubs/todo diff --git a/.github/workflows/stubs.yml b/.github/workflows/stubs.yml new file mode 100644 index 000000000..715e923c3 --- /dev/null +++ b/.github/workflows/stubs.yml @@ -0,0 +1,71 @@ +name: Check type stubs +env: + version: 10.0.0 + +on: + push: + branches: + - "master" + pull_request: + types: [opened, synchronize, reopened, ready_for_review] + branches: + - "master" + workflow_dispatch: + +defaults: + run: + shell: bash + +jobs: + stubtest: + if: (github.event_name != 'pull_request') || (github.event.pull_request.draft == false) + runs-on: ubuntu-24.04 + env: + PYTHON_VERSION: "3.14" + + steps: + - uses: actions/checkout@v6 + + - name: Install dependencies (SCIPOptSuite) + run: | + wget --quiet --no-check-certificate "https://github.com/scipopt/scip/releases/download/v${{ env.version }}/scipoptsuite_${{ env.version }}-1+jammy_amd64.deb" + sudo apt-get update && sudo apt install -y ./scipoptsuite_${{ env.version }}-1+jammy_amd64.deb + + - name: Setup python ${{ env.PYTHON_VERSION }} + uses: actions/setup-python@v4 + with: + python-version: ${{ env.PYTHON_VERSION }} + + - name: Install mypy + run: | + python -m pip install mypy + + - name: Install PySCIPOpt + run: | + export CFLAGS="-O0 -ggdb -Wall -Wextra -Werror -Wno-error=deprecated-declarations" # Debug mode. More warnings. Warnings as errors, but allow deprecated declarations. + python -m pip install . -v 2>&1 | tee build.log + + - name: Run MyPy + run: python -m mypy --package pyscipopt + + - name: Run stubtest + run: stubs/test.sh + + lint: + runs-on: ubuntu-latest + env: + FILES: src/pyscipopt/scip.pyi + + steps: + - uses: actions/checkout@v6 + + - name: Install Ruff + uses: astral-sh/ruff-action@v3 + with: + args: "--version" + + - name: Lint type stubs + run: ruff check ${{ env.FILES }} --extend-select PYI + + - name: Format type stubs + run: ruff format ${{ env.FILES }} diff --git a/src/pyscipopt/__init__.py b/src/pyscipopt/__init__.py index 7e32ca6c1..fafa440ad 100644 --- a/src/pyscipopt/__init__.py +++ b/src/pyscipopt/__init__.py @@ -4,7 +4,7 @@ import os if hasattr(os, 'add_dll_directory'): if os.getenv('SCIPOPTDIR'): - os.add_dll_directory(os.path.join(os.getenv('SCIPOPTDIR').strip('"'), 'bin')) + os.add_dll_directory(os.path.join(os.environ['SCIPOPTDIR'].strip('"'), 'bin')) # export user-relevant objects: from pyscipopt.Multidict import multidict as multidict diff --git a/src/pyscipopt/recipes/getLocalConss.py b/src/pyscipopt/recipes/getLocalConss.py index 2de03049e..c1c659b69 100644 --- a/src/pyscipopt/recipes/getLocalConss.py +++ b/src/pyscipopt/recipes/getLocalConss.py @@ -24,7 +24,7 @@ def getLocalConss(model: Model, node = None) -> List[List[Constraint]]: else: cur_node = node - added_conss = [] + added_conss: List[Constraint] = [] while cur_node is not None: added_conss = cur_node.getAddedConss() + added_conss cur_node = cur_node.getParent() diff --git a/src/pyscipopt/scip.pyi b/src/pyscipopt/scip.pyi index 571f987d7..c89521f00 100644 --- a/src/pyscipopt/scip.pyi +++ b/src/pyscipopt/scip.pyi @@ -379,9 +379,9 @@ class MatrixExpr(numpy.ndarray): def sum(self, *args, **kwargs): ... def __add__(self, other): ... def __eq__(self, other: object) -> bool: ... - def __ge__(self, other: object) -> bool: ... + def __ge__(self, other: object) -> MatrixExprCons: ... def __iadd__(self, other): ... - def __le__(self, other: object) -> bool: ... + def __le__(self, other: object) -> MatrixExprCons: ... def __matmul__(self, *args, **kwargs): ... def __mul__(self, other): ... def __pow__(self, other): ... @@ -394,8 +394,8 @@ class MatrixExpr(numpy.ndarray): class MatrixExprCons(numpy.ndarray): def __eq__(self, other: object) -> bool: ... - def __ge__(self, other: object) -> bool: ... - def __le__(self, other: object) -> bool: ... + def __ge__(self, other: object) -> MatrixExprCons: ... + def __le__(self, other: object) -> MatrixExprCons: ... class MatrixGenExpr(MatrixExpr): ... @@ -1300,14 +1300,14 @@ class Statistics: copying_time: float problem_name: str presolved_problem_name: str - n_runs: int = None - n_nodes: int = None + n_runs: int | None = None + n_nodes: int | None = None n_solutions_found: int = -1 - first_solution: float = None - primal_bound: float = None - dual_bound: float = None - gap: float = None - primal_dual_integral: float = None + first_solution: float | None = None + primal_bound: float | None = None + dual_bound: float | None = None + gap: float | None = None + primal_dual_integral: float | None = None @property def n_binary_vars(self): ... @property diff --git a/stubs/allowlist b/stubs/allowlist new file mode 100644 index 000000000..a9747c848 --- /dev/null +++ b/stubs/allowlist @@ -0,0 +1,3 @@ +.*.__reduce_cython__ +.*.__setstate_cython__ +pyscipopt.scip.__test__ diff --git a/stubs/test.sh b/stubs/test.sh new file mode 100755 index 000000000..e35305576 --- /dev/null +++ b/stubs/test.sh @@ -0,0 +1,10 @@ +#!/bin/bash -e + +# Test the stubs for pyscipopt using stubtest +# This checks that the type hints in the stubs are consistent with the actual implementation +# Prerequisite: install mypy (which provides stubtest) in the same environment as pyscipopt +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +python -m mypy.stubtest \ + --allowlist "$SCRIPT_DIR/allowlist" \ + --allowlist "$SCRIPT_DIR/todo" \ + pyscipopt diff --git a/stubs/todo b/stubs/todo new file mode 100644 index 000000000..81411bcf8 --- /dev/null +++ b/stubs/todo @@ -0,0 +1,3680 @@ +pyscipopt.Benders +pyscipopt.Benders.__init__ +pyscipopt.Benders.benderscreatesub +pyscipopt.Benders.bendersexit +pyscipopt.Benders.bendersexitpre +pyscipopt.Benders.bendersexitsol +pyscipopt.Benders.bendersfree +pyscipopt.Benders.bendersfreesub +pyscipopt.Benders.bendersgetvar +pyscipopt.Benders.bendersinit +pyscipopt.Benders.bendersinitpre +pyscipopt.Benders.bendersinitsol +pyscipopt.Benders.benderspostsolve +pyscipopt.Benders.benderspresubsolve +pyscipopt.Benders.benderssolvesub +pyscipopt.Benders.benderssolvesubconvex +pyscipopt.Benderscut +pyscipopt.Benderscut.__init__ +pyscipopt.Benderscut.benderscutexec +pyscipopt.Benderscut.benderscutexit +pyscipopt.Benderscut.benderscutexitsol +pyscipopt.Benderscut.benderscutfree +pyscipopt.Benderscut.benderscutinit +pyscipopt.Benderscut.benderscutinitsol +pyscipopt.Branchrule +pyscipopt.Branchrule.__init__ +pyscipopt.Branchrule.branchexecext +pyscipopt.Branchrule.branchexeclp +pyscipopt.Branchrule.branchexecps +pyscipopt.Branchrule.branchexit +pyscipopt.Branchrule.branchexitsol +pyscipopt.Branchrule.branchfree +pyscipopt.Branchrule.branchinit +pyscipopt.Branchrule.branchinitsol +pyscipopt.Conshdlr +pyscipopt.Conshdlr.__init__ +pyscipopt.Conshdlr.consactive +pyscipopt.Conshdlr.conscheck +pyscipopt.Conshdlr.conscopy +pyscipopt.Conshdlr.consdeactive +pyscipopt.Conshdlr.consdelete +pyscipopt.Conshdlr.consdelvars +pyscipopt.Conshdlr.consdisable +pyscipopt.Conshdlr.consenable +pyscipopt.Conshdlr.consenfolp +pyscipopt.Conshdlr.consenfops +pyscipopt.Conshdlr.consenforelax +pyscipopt.Conshdlr.consexit +pyscipopt.Conshdlr.consexitpre +pyscipopt.Conshdlr.consexitsol +pyscipopt.Conshdlr.consfree +pyscipopt.Conshdlr.consgetdivebdchgs +pyscipopt.Conshdlr.consgetnvars +pyscipopt.Conshdlr.consgetpermsymgraph +pyscipopt.Conshdlr.consgetsignedpermsymgraph +pyscipopt.Conshdlr.consgetvars +pyscipopt.Conshdlr.consinit +pyscipopt.Conshdlr.consinitlp +pyscipopt.Conshdlr.consinitpre +pyscipopt.Conshdlr.consinitsol +pyscipopt.Conshdlr.conslock +pyscipopt.Conshdlr.consparse +pyscipopt.Conshdlr.conspresol +pyscipopt.Conshdlr.consprint +pyscipopt.Conshdlr.consprop +pyscipopt.Conshdlr.consresprop +pyscipopt.Conshdlr.conssepalp +pyscipopt.Conshdlr.conssepasol +pyscipopt.Conshdlr.constrans +pyscipopt.Constraint +pyscipopt.Constraint.__init__ +pyscipopt.Constraint.getConshdlrName +pyscipopt.Constraint.isActive +pyscipopt.Constraint.isChecked +pyscipopt.Constraint.isDynamic +pyscipopt.Constraint.isEnforced +pyscipopt.Constraint.isInitial +pyscipopt.Constraint.isKnapsack +pyscipopt.Constraint.isLinear +pyscipopt.Constraint.isLinearType +pyscipopt.Constraint.isLocal +pyscipopt.Constraint.isModifiable +pyscipopt.Constraint.isNonlinear +pyscipopt.Constraint.isOriginal +pyscipopt.Constraint.isPropagated +pyscipopt.Constraint.isRemovable +pyscipopt.Constraint.isSeparated +pyscipopt.Constraint.isStickingAtNode +pyscipopt.Eventhdlr +pyscipopt.Eventhdlr.__init__ +pyscipopt.Eventhdlr.eventcopy +pyscipopt.Eventhdlr.eventdelete +pyscipopt.Eventhdlr.eventexec +pyscipopt.Eventhdlr.eventexit +pyscipopt.Eventhdlr.eventexitsol +pyscipopt.Eventhdlr.eventfree +pyscipopt.Eventhdlr.eventinit +pyscipopt.Eventhdlr.eventinitsol +pyscipopt.Expr +pyscipopt.Expr.__pow__ +pyscipopt.Expr.degree +pyscipopt.Expr.normalize +pyscipopt.ExprCons +pyscipopt.ExprCons.normalize +pyscipopt.Heur +pyscipopt.Heur.__init__ +pyscipopt.Heur.heurexec +pyscipopt.Heur.heurexit +pyscipopt.Heur.heurexitsol +pyscipopt.Heur.heurfree +pyscipopt.Heur.heurinit +pyscipopt.Heur.heurinitsol +pyscipopt.IISfinder +pyscipopt.IISfinder.__init__ +pyscipopt.IISfinder.iisfinderexec +pyscipopt.IISfinder.iisfinderfree +pyscipopt.LP +pyscipopt.LP.addCol +pyscipopt.LP.addCols +pyscipopt.LP.addRow +pyscipopt.LP.addRows +pyscipopt.LP.chgBound +pyscipopt.LP.chgCoef +pyscipopt.LP.chgObj +pyscipopt.LP.chgSide +pyscipopt.LP.clear +pyscipopt.LP.delCols +pyscipopt.LP.delRows +pyscipopt.LP.getActivity +pyscipopt.LP.getBasisInds +pyscipopt.LP.getBounds +pyscipopt.LP.getDual +pyscipopt.LP.getDualRay +pyscipopt.LP.getIntParam +pyscipopt.LP.getNIterations +pyscipopt.LP.getObjVal +pyscipopt.LP.getPrimal +pyscipopt.LP.getPrimalRay +pyscipopt.LP.getRealParam +pyscipopt.LP.getRedcost +pyscipopt.LP.getSides +pyscipopt.LP.infinity +pyscipopt.LP.isDualFeasible +pyscipopt.LP.isInfinity +pyscipopt.LP.isOptimal +pyscipopt.LP.isPrimalFeasible +pyscipopt.LP.ncols +pyscipopt.LP.nrows +pyscipopt.LP.readLP +pyscipopt.LP.setIntParam +pyscipopt.LP.setRealParam +pyscipopt.LP.solve +pyscipopt.LP.writeLP +pyscipopt.MatrixConstraint.getConshdlrName +pyscipopt.MatrixConstraint.isActive +pyscipopt.MatrixConstraint.isChecked +pyscipopt.MatrixConstraint.isDynamic +pyscipopt.MatrixConstraint.isEnforced +pyscipopt.MatrixConstraint.isInitial +pyscipopt.MatrixConstraint.isLinear +pyscipopt.MatrixConstraint.isLocal +pyscipopt.MatrixConstraint.isModifiable +pyscipopt.MatrixConstraint.isNonlinear +pyscipopt.MatrixConstraint.isPropagated +pyscipopt.MatrixConstraint.isRemovable +pyscipopt.MatrixConstraint.isSeparated +pyscipopt.MatrixConstraint.isStickingAtNode +pyscipopt.MatrixExpr.__matmul__ +pyscipopt.MatrixExpr.sum +pyscipopt.MatrixVariable.getAvgSol +pyscipopt.MatrixVariable.getCol +pyscipopt.MatrixVariable.getIndex +pyscipopt.MatrixVariable.getLPSol +pyscipopt.MatrixVariable.getLbGlobal +pyscipopt.MatrixVariable.getLbLocal +pyscipopt.MatrixVariable.getLbOriginal +pyscipopt.MatrixVariable.getObj +pyscipopt.MatrixVariable.getUbGlobal +pyscipopt.MatrixVariable.getUbLocal +pyscipopt.MatrixVariable.getUbOriginal +pyscipopt.MatrixVariable.isInLP +pyscipopt.MatrixVariable.varMayRound +pyscipopt.MatrixVariable.vtype +pyscipopt.Model +pyscipopt.Model._createConsGenNonlinear +pyscipopt.Model._createConsLinear +pyscipopt.Model._createConsNonlinear +pyscipopt.Model._createConsQuadratic +pyscipopt.Model._getStageNames +pyscipopt.Model.activateBenders +pyscipopt.Model.addBendersSubproblem +pyscipopt.Model.addCoefKnapsack +pyscipopt.Model.addCoefLinear +pyscipopt.Model.addCons +pyscipopt.Model.addConsAnd +pyscipopt.Model.addConsCardinality +pyscipopt.Model.addConsCoeff +pyscipopt.Model.addConsDisjunction +pyscipopt.Model.addConsElemDisjunction +pyscipopt.Model.addConsIndicator +pyscipopt.Model.addConsKnapsack +pyscipopt.Model.addConsLocal +pyscipopt.Model.addConsNode +pyscipopt.Model.addConsOr +pyscipopt.Model.addConsSOS1 +pyscipopt.Model.addConsSOS2 +pyscipopt.Model.addConsXor +pyscipopt.Model.addConss +pyscipopt.Model.addCut +pyscipopt.Model.addExprNonlinear +pyscipopt.Model.addMatrixCons +pyscipopt.Model.addMatrixConsIndicator +pyscipopt.Model.addMatrixVar +pyscipopt.Model.addObjoffset +pyscipopt.Model.addPoolCut +pyscipopt.Model.addPyCons +pyscipopt.Model.addRowDive +pyscipopt.Model.addRowExact +pyscipopt.Model.addSol +pyscipopt.Model.addVar +pyscipopt.Model.addVarLocks +pyscipopt.Model.addVarLocksType +pyscipopt.Model.addVarSOS1 +pyscipopt.Model.addVarSOS2 +pyscipopt.Model.addVarToRow +pyscipopt.Model.allColsInLP +pyscipopt.Model.allowNegSlackExact +pyscipopt.Model.appendVarSOS1 +pyscipopt.Model.appendVarSOS2 +pyscipopt.Model.applyCutsProbing +pyscipopt.Model.attachEventHandlerCallback +pyscipopt.Model.backtrackProbing +pyscipopt.Model.branchLPExact +pyscipopt.Model.branchVar +pyscipopt.Model.branchVarVal +pyscipopt.Model.cacheRowExtensions +pyscipopt.Model.calcChildEstimate +pyscipopt.Model.calcNodeselPriority +pyscipopt.Model.catchEvent +pyscipopt.Model.catchRowEvent +pyscipopt.Model.catchVarEvent +pyscipopt.Model.checkBendersSubproblemOptimality +pyscipopt.Model.checkQuadraticNonlinear +pyscipopt.Model.checkSol +pyscipopt.Model.chgCapacityKnapsack +pyscipopt.Model.chgCoefLinear +pyscipopt.Model.chgLhs +pyscipopt.Model.chgReoptObjective +pyscipopt.Model.chgRhs +pyscipopt.Model.chgRowLhsDive +pyscipopt.Model.chgRowRhsDive +pyscipopt.Model.chgVarBranchPriority +pyscipopt.Model.chgVarLb +pyscipopt.Model.chgVarLbDive +pyscipopt.Model.chgVarLbGlobal +pyscipopt.Model.chgVarLbNode +pyscipopt.Model.chgVarLbProbing +pyscipopt.Model.chgVarObjDive +pyscipopt.Model.chgVarObjProbing +pyscipopt.Model.chgVarType +pyscipopt.Model.chgVarUb +pyscipopt.Model.chgVarUbDive +pyscipopt.Model.chgVarUbGlobal +pyscipopt.Model.chgVarUbNode +pyscipopt.Model.chgVarUbProbing +pyscipopt.Model.computeBestSolSubproblems +pyscipopt.Model.constructLP +pyscipopt.Model.copyLargeNeighborhoodSearch +pyscipopt.Model.count +pyscipopt.Model.createChild +pyscipopt.Model.createCons +pyscipopt.Model.createConsFromExpr +pyscipopt.Model.createEmptyRowSepa +pyscipopt.Model.createEmptyRowUnspec +pyscipopt.Model.createOrigSol +pyscipopt.Model.createPartialSol +pyscipopt.Model.createProbBasic +pyscipopt.Model.createSol +pyscipopt.Model.cutoffNode +pyscipopt.Model.deactivatePricer +pyscipopt.Model.delCoefLinear +pyscipopt.Model.delCons +pyscipopt.Model.delConsLocal +pyscipopt.Model.delVar +pyscipopt.Model.disableDebugSol +pyscipopt.Model.disablePropagation +pyscipopt.Model.dropEvent +pyscipopt.Model.dropRowEvent +pyscipopt.Model.dropVarEvent +pyscipopt.Model.enableDebugSol +pyscipopt.Model.enableExactSolving +pyscipopt.Model.enableReoptimization +pyscipopt.Model.endDive +pyscipopt.Model.endProbing +pyscipopt.Model.endStrongbranch +pyscipopt.Model.epsilon +pyscipopt.Model.feasCeil +pyscipopt.Model.feasFloor +pyscipopt.Model.feasFrac +pyscipopt.Model.feasRound +pyscipopt.Model.feastol +pyscipopt.Model.fixVar +pyscipopt.Model.fixVarProbing +pyscipopt.Model.flushRowExtensions +pyscipopt.Model.frac +pyscipopt.Model.freeBendersSubproblems +pyscipopt.Model.freeProb +pyscipopt.Model.freeReoptSolve +pyscipopt.Model.freeSol +pyscipopt.Model.freeTransform +pyscipopt.Model.from_ptr +pyscipopt.Model.generateIIS +pyscipopt.Model.getActivity +pyscipopt.Model.getBendersAuxiliaryVar +pyscipopt.Model.getBendersSubproblem +pyscipopt.Model.getBendersVar +pyscipopt.Model.getBestChild +pyscipopt.Model.getBestLeaf +pyscipopt.Model.getBestNode +pyscipopt.Model.getBestSibling +pyscipopt.Model.getBestSol +pyscipopt.Model.getBestboundNode +pyscipopt.Model.getBipartiteGraphRepresentation +pyscipopt.Model.getBranchScoreMultiple +pyscipopt.Model.getCapacityKnapsack +pyscipopt.Model.getChildren +pyscipopt.Model.getColRedCost +pyscipopt.Model.getCondition +pyscipopt.Model.getConsNVars +pyscipopt.Model.getConsVals +pyscipopt.Model.getConsVars +pyscipopt.Model.getConss +pyscipopt.Model.getCurrentNode +pyscipopt.Model.getCutEfficacy +pyscipopt.Model.getCutLPSolCutoffDistance +pyscipopt.Model.getCutoffbound +pyscipopt.Model.getDepth +pyscipopt.Model.getDualMultiplier +pyscipopt.Model.getDualSolVal +pyscipopt.Model.getDualbound +pyscipopt.Model.getDualboundRoot +pyscipopt.Model.getDualfarkasKnapsack +pyscipopt.Model.getDualfarkasLinear +pyscipopt.Model.getDualsolKnapsack +pyscipopt.Model.getDualsolLinear +pyscipopt.Model.getGap +pyscipopt.Model.getHeurTiming +pyscipopt.Model.getIIS +pyscipopt.Model.getLPBInvARow +pyscipopt.Model.getLPBInvRow +pyscipopt.Model.getLPBasisInd +pyscipopt.Model.getLPBranchCands +pyscipopt.Model.getLPColsData +pyscipopt.Model.getLPObjVal +pyscipopt.Model.getLPRowsData +pyscipopt.Model.getLPSolstat +pyscipopt.Model.getLeaves +pyscipopt.Model.getLhs +pyscipopt.Model.getLinearConsIndicator +pyscipopt.Model.getLocalEstimate +pyscipopt.Model.getLowerbound +pyscipopt.Model.getMajorVersion +pyscipopt.Model.getMaxDepth +pyscipopt.Model.getMinorVersion +pyscipopt.Model.getNBestSolsFound +pyscipopt.Model.getNBinVars +pyscipopt.Model.getNChildren +pyscipopt.Model.getNConss +pyscipopt.Model.getNContVars +pyscipopt.Model.getNCountedSols +pyscipopt.Model.getNCuts +pyscipopt.Model.getNCutsApplied +pyscipopt.Model.getNFeasibleLeaves +pyscipopt.Model.getNImplVars +pyscipopt.Model.getNInfeasibleLeaves +pyscipopt.Model.getNIntVars +pyscipopt.Model.getNLPBranchCands +pyscipopt.Model.getNLPCols +pyscipopt.Model.getNLPIterations +pyscipopt.Model.getNLPRows +pyscipopt.Model.getNLPs +pyscipopt.Model.getNLeaves +pyscipopt.Model.getNLimSolsFound +pyscipopt.Model.getNNlRows +pyscipopt.Model.getNNodeLPIterations +pyscipopt.Model.getNNodes +pyscipopt.Model.getNReaders +pyscipopt.Model.getNSepaRounds +pyscipopt.Model.getNSiblings +pyscipopt.Model.getNSols +pyscipopt.Model.getNSolsFound +pyscipopt.Model.getNStrongbranchLPIterations +pyscipopt.Model.getNTotalNodes +pyscipopt.Model.getNVars +pyscipopt.Model.getNVarsAnd +pyscipopt.Model.getNlRowActivityBounds +pyscipopt.Model.getNlRowSolActivity +pyscipopt.Model.getNlRowSolFeasibility +pyscipopt.Model.getNlRows +pyscipopt.Model.getObjVal +pyscipopt.Model.getObjective +pyscipopt.Model.getObjectiveSense +pyscipopt.Model.getObjlimit +pyscipopt.Model.getObjoffset +pyscipopt.Model.getOpenNodes +pyscipopt.Model.getParam +pyscipopt.Model.getParams +pyscipopt.Model.getPlungeDepth +pyscipopt.Model.getPresolvingTime +pyscipopt.Model.getPrimalRay +pyscipopt.Model.getPrimalRayVal +pyscipopt.Model.getPrimalbound +pyscipopt.Model.getPrioChild +pyscipopt.Model.getPrioSibling +pyscipopt.Model.getProbName +pyscipopt.Model.getProbingDepth +pyscipopt.Model.getPseudoBranchCands +pyscipopt.Model.getReadingTime +pyscipopt.Model.getResultantAnd +pyscipopt.Model.getRhs +pyscipopt.Model.getRowActivity +pyscipopt.Model.getRowDualSol +pyscipopt.Model.getRowLPActivity +pyscipopt.Model.getRowLinear +pyscipopt.Model.getRowNumIntCols +pyscipopt.Model.getRowObjParallelism +pyscipopt.Model.getRowParallelism +pyscipopt.Model.getSiblings +pyscipopt.Model.getSlack +pyscipopt.Model.getSlackVarIndicator +pyscipopt.Model.getSolObjVal +pyscipopt.Model.getSolTime +pyscipopt.Model.getSolVal +pyscipopt.Model.getSols +pyscipopt.Model.getSolvingTime +pyscipopt.Model.getStage +pyscipopt.Model.getStageName +pyscipopt.Model.getStatus +pyscipopt.Model.getTechVersion +pyscipopt.Model.getTermsQuadratic +pyscipopt.Model.getTotalTime +pyscipopt.Model.getTransformedCons +pyscipopt.Model.getTransformedVar +pyscipopt.Model.getTreesizeEstimation +pyscipopt.Model.getVal +pyscipopt.Model.getValsLinear +pyscipopt.Model.getVarDict +pyscipopt.Model.getVarLbDive +pyscipopt.Model.getVarPseudocost +pyscipopt.Model.getVarPseudocostScore +pyscipopt.Model.getVarRedcost +pyscipopt.Model.getVarStrongbranch +pyscipopt.Model.getVarStrongbranchLast +pyscipopt.Model.getVarStrongbranchNode +pyscipopt.Model.getVarUbDive +pyscipopt.Model.getVars +pyscipopt.Model.getVarsAnd +pyscipopt.Model.getWeightsKnapsack +pyscipopt.Model.hasPrimalRay +pyscipopt.Model.hideOutput +pyscipopt.Model.inProbing +pyscipopt.Model.inRepropagation +pyscipopt.Model.includeBenders +pyscipopt.Model.includeBendersDefaultCuts +pyscipopt.Model.includeBenderscut +pyscipopt.Model.includeBranchrule +pyscipopt.Model.includeConshdlr +pyscipopt.Model.includeCutsel +pyscipopt.Model.includeDefaultPlugins +pyscipopt.Model.includeEventhdlr +pyscipopt.Model.includeHeur +pyscipopt.Model.includeIISfinder +pyscipopt.Model.includeNodesel +pyscipopt.Model.includePresol +pyscipopt.Model.includePricer +pyscipopt.Model.includeProp +pyscipopt.Model.includeReader +pyscipopt.Model.includeRelax +pyscipopt.Model.includeSepa +pyscipopt.Model.infinity +pyscipopt.Model.initBendersDefault +pyscipopt.Model.interruptSolve +pyscipopt.Model.isAndConsSorted +pyscipopt.Model.isCutEfficacious +pyscipopt.Model.isEQ +pyscipopt.Model.isExact +pyscipopt.Model.isFeasEQ +pyscipopt.Model.isFeasGE +pyscipopt.Model.isFeasGT +pyscipopt.Model.isFeasIntegral +pyscipopt.Model.isFeasLE +pyscipopt.Model.isFeasLT +pyscipopt.Model.isFeasNegative +pyscipopt.Model.isFeasPositive +pyscipopt.Model.isFeasZero +pyscipopt.Model.isGE +pyscipopt.Model.isGT +pyscipopt.Model.isHugeValue +pyscipopt.Model.isInfinity +pyscipopt.Model.isLE +pyscipopt.Model.isLPSolBasic +pyscipopt.Model.isLT +pyscipopt.Model.isNLPConstructed +pyscipopt.Model.isNegative +pyscipopt.Model.isObjChangedProbing +pyscipopt.Model.isPositive +pyscipopt.Model.isZero +pyscipopt.Model.lpiGetIterations +pyscipopt.Model.markDoNotAggrVar +pyscipopt.Model.markDoNotMultaggrVar +pyscipopt.Model.newProbingNode +pyscipopt.Model.optimize +pyscipopt.Model.optimizeNogil +pyscipopt.Model.presolve +pyscipopt.Model.printBestSol +pyscipopt.Model.printCons +pyscipopt.Model.printExternalCodeVersions +pyscipopt.Model.printNlRow +pyscipopt.Model.printProblem +pyscipopt.Model.printRow +pyscipopt.Model.printSol +pyscipopt.Model.printStatistics +pyscipopt.Model.printStatisticsJson +pyscipopt.Model.printVersion +pyscipopt.Model.propagateProbing +pyscipopt.Model.readParams +pyscipopt.Model.readProblem +pyscipopt.Model.readSol +pyscipopt.Model.readSolFile +pyscipopt.Model.redirectOutput +pyscipopt.Model.relax +pyscipopt.Model.releaseRow +pyscipopt.Model.repropagateNode +pyscipopt.Model.resetParam +pyscipopt.Model.resetParams +pyscipopt.Model.restartSolve +pyscipopt.Model.separateSol +pyscipopt.Model.setBendersSubproblemIsConvex +pyscipopt.Model.setBoolParam +pyscipopt.Model.setCharParam +pyscipopt.Model.setCheck +pyscipopt.Model.setEmphasis +pyscipopt.Model.setEnforced +pyscipopt.Model.setHeurTiming +pyscipopt.Model.setHeuristics +pyscipopt.Model.setInitial +pyscipopt.Model.setIntParam +pyscipopt.Model.setLogfile +pyscipopt.Model.setLongintParam +pyscipopt.Model.setMaximize +pyscipopt.Model.setMinimize +pyscipopt.Model.setModifiable +pyscipopt.Model.setObjIntegral +pyscipopt.Model.setObjective +pyscipopt.Model.setObjlimit +pyscipopt.Model.setParam +pyscipopt.Model.setParams +pyscipopt.Model.setParamsCountsols +pyscipopt.Model.setPresolve +pyscipopt.Model.setProbName +pyscipopt.Model.setRealParam +pyscipopt.Model.setRelaxSolVal +pyscipopt.Model.setRemovable +pyscipopt.Model.setSeparating +pyscipopt.Model.setSolVal +pyscipopt.Model.setStringParam +pyscipopt.Model.setupBendersSubproblem +pyscipopt.Model.solveBendersSubproblem +pyscipopt.Model.solveConcurrent +pyscipopt.Model.solveDiveLP +pyscipopt.Model.solveProbingLP +pyscipopt.Model.sortAndCons +pyscipopt.Model.startDive +pyscipopt.Model.startProbing +pyscipopt.Model.startStrongbranch +pyscipopt.Model.tightenVarLb +pyscipopt.Model.tightenVarLbGlobal +pyscipopt.Model.tightenVarUb +pyscipopt.Model.tightenVarUbGlobal +pyscipopt.Model.to_ptr +pyscipopt.Model.translateSubSol +pyscipopt.Model.trySol +pyscipopt.Model.updateBendersLowerbounds +pyscipopt.Model.updateNodeLowerbound +pyscipopt.Model.updateVarPseudocost +pyscipopt.Model.version +pyscipopt.Model.writeBestSol +pyscipopt.Model.writeBestTransSol +pyscipopt.Model.writeLP +pyscipopt.Model.writeMIP +pyscipopt.Model.writeName +pyscipopt.Model.writeParams +pyscipopt.Model.writeProblem +pyscipopt.Model.writeSol +pyscipopt.Model.writeStatistics +pyscipopt.Model.writeStatisticsJson +pyscipopt.Model.writeTransSol +pyscipopt.Nodesel +pyscipopt.Nodesel.__init__ +pyscipopt.Nodesel.nodecomp +pyscipopt.Nodesel.nodeexit +pyscipopt.Nodesel.nodeexitsol +pyscipopt.Nodesel.nodefree +pyscipopt.Nodesel.nodeinit +pyscipopt.Nodesel.nodeinitsol +pyscipopt.Nodesel.nodeselect +pyscipopt.Presol +pyscipopt.Presol.__init__ +pyscipopt.Presol.presolexec +pyscipopt.Presol.presolexit +pyscipopt.Presol.presolexitpre +pyscipopt.Presol.presolfree +pyscipopt.Presol.presolinit +pyscipopt.Presol.presolinitpre +pyscipopt.Pricer +pyscipopt.Pricer.__init__ +pyscipopt.Pricer.pricerexit +pyscipopt.Pricer.pricerexitsol +pyscipopt.Pricer.pricerfarkas +pyscipopt.Pricer.pricerfree +pyscipopt.Pricer.pricerinit +pyscipopt.Pricer.pricerinitsol +pyscipopt.Pricer.pricerredcost +pyscipopt.Prop +pyscipopt.Prop.__init__ +pyscipopt.Prop.propexec +pyscipopt.Prop.propexit +pyscipopt.Prop.propexitpre +pyscipopt.Prop.propexitsol +pyscipopt.Prop.propfree +pyscipopt.Prop.propinit +pyscipopt.Prop.propinitpre +pyscipopt.Prop.propinitsol +pyscipopt.Prop.proppresol +pyscipopt.Prop.propresprop +pyscipopt.Reader +pyscipopt.Reader.__init__ +pyscipopt.Reader.readerfree +pyscipopt.Reader.readerread +pyscipopt.Reader.readerwrite +pyscipopt.SCIP_BENDERSENFOTYPE.__init__ +pyscipopt.SCIP_BRANCHDIR.__init__ +pyscipopt.SCIP_EVENTTYPE.__init__ +pyscipopt.SCIP_HEURTIMING.__init__ +pyscipopt.SCIP_IMPLINTTYPE.__init__ +pyscipopt.SCIP_LOCKTYPE.__init__ +pyscipopt.SCIP_LPPARAM.__init__ +pyscipopt.SCIP_LPSOLSTAT.__init__ +pyscipopt.SCIP_NODETYPE.__init__ +pyscipopt.SCIP_PARAMEMPHASIS.__init__ +pyscipopt.SCIP_PARAMSETTING.__init__ +pyscipopt.SCIP_PRESOLTIMING.__init__ +pyscipopt.SCIP_PROPTIMING.__init__ +pyscipopt.SCIP_RESULT.__init__ +pyscipopt.SCIP_ROWORIGINTYPE.__init__ +pyscipopt.SCIP_SOLORIGIN.__init__ +pyscipopt.SCIP_STAGE.__init__ +pyscipopt.SCIP_STATUS.__init__ +pyscipopt.Sepa +pyscipopt.Sepa.__init__ +pyscipopt.Sepa.sepaexeclp +pyscipopt.Sepa.sepaexecsol +pyscipopt.Sepa.sepaexit +pyscipopt.Sepa.sepaexitsol +pyscipopt.Sepa.sepafree +pyscipopt.Sepa.sepainit +pyscipopt.Sepa.sepainitsol +pyscipopt.Variable +pyscipopt.Variable.getAvgSol +pyscipopt.Variable.getCol +pyscipopt.Variable.getImplType +pyscipopt.Variable.getIndex +pyscipopt.Variable.getLPSol +pyscipopt.Variable.getLbGlobal +pyscipopt.Variable.getLbLocal +pyscipopt.Variable.getLbOriginal +pyscipopt.Variable.getNBranchings +pyscipopt.Variable.getNBranchingsCurrentRun +pyscipopt.Variable.getNLocksDown +pyscipopt.Variable.getNLocksDownType +pyscipopt.Variable.getNLocksUp +pyscipopt.Variable.getNLocksUpType +pyscipopt.Variable.getObj +pyscipopt.Variable.getStatus +pyscipopt.Variable.getUbGlobal +pyscipopt.Variable.getUbLocal +pyscipopt.Variable.getUbOriginal +pyscipopt.Variable.isActive +pyscipopt.Variable.isBinary +pyscipopt.Variable.isDeletable +pyscipopt.Variable.isImpliedIntegral +pyscipopt.Variable.isInLP +pyscipopt.Variable.isIntegral +pyscipopt.Variable.isNonImpliedIntegral +pyscipopt.Variable.isOriginal +pyscipopt.Variable.isRelaxationOnly +pyscipopt.Variable.markRelaxationOnly +pyscipopt.Variable.ptr +pyscipopt.Variable.varMayRound +pyscipopt.Variable.vtype +pyscipopt._version.__conditional_annotations__ +pyscipopt.recipes.getLocalConss.Constraint +pyscipopt.recipes.getLocalConss.Constraint.__init__ +pyscipopt.recipes.getLocalConss.Constraint.getConshdlrName +pyscipopt.recipes.getLocalConss.Constraint.isActive +pyscipopt.recipes.getLocalConss.Constraint.isChecked +pyscipopt.recipes.getLocalConss.Constraint.isDynamic +pyscipopt.recipes.getLocalConss.Constraint.isEnforced +pyscipopt.recipes.getLocalConss.Constraint.isInitial +pyscipopt.recipes.getLocalConss.Constraint.isKnapsack +pyscipopt.recipes.getLocalConss.Constraint.isLinear +pyscipopt.recipes.getLocalConss.Constraint.isLinearType +pyscipopt.recipes.getLocalConss.Constraint.isLocal +pyscipopt.recipes.getLocalConss.Constraint.isModifiable +pyscipopt.recipes.getLocalConss.Constraint.isNonlinear +pyscipopt.recipes.getLocalConss.Constraint.isOriginal +pyscipopt.recipes.getLocalConss.Constraint.isPropagated +pyscipopt.recipes.getLocalConss.Constraint.isRemovable +pyscipopt.recipes.getLocalConss.Constraint.isSeparated +pyscipopt.recipes.getLocalConss.Constraint.isStickingAtNode +pyscipopt.recipes.getLocalConss.Model +pyscipopt.recipes.getLocalConss.Model._createConsGenNonlinear +pyscipopt.recipes.getLocalConss.Model._createConsLinear +pyscipopt.recipes.getLocalConss.Model._createConsNonlinear +pyscipopt.recipes.getLocalConss.Model._createConsQuadratic +pyscipopt.recipes.getLocalConss.Model._getStageNames +pyscipopt.recipes.getLocalConss.Model.activateBenders +pyscipopt.recipes.getLocalConss.Model.addBendersSubproblem +pyscipopt.recipes.getLocalConss.Model.addCoefKnapsack +pyscipopt.recipes.getLocalConss.Model.addCoefLinear +pyscipopt.recipes.getLocalConss.Model.addCons +pyscipopt.recipes.getLocalConss.Model.addConsAnd +pyscipopt.recipes.getLocalConss.Model.addConsCardinality +pyscipopt.recipes.getLocalConss.Model.addConsCoeff +pyscipopt.recipes.getLocalConss.Model.addConsDisjunction +pyscipopt.recipes.getLocalConss.Model.addConsElemDisjunction +pyscipopt.recipes.getLocalConss.Model.addConsIndicator +pyscipopt.recipes.getLocalConss.Model.addConsKnapsack +pyscipopt.recipes.getLocalConss.Model.addConsLocal +pyscipopt.recipes.getLocalConss.Model.addConsNode +pyscipopt.recipes.getLocalConss.Model.addConsOr +pyscipopt.recipes.getLocalConss.Model.addConsSOS1 +pyscipopt.recipes.getLocalConss.Model.addConsSOS2 +pyscipopt.recipes.getLocalConss.Model.addConsXor +pyscipopt.recipes.getLocalConss.Model.addConss +pyscipopt.recipes.getLocalConss.Model.addCut +pyscipopt.recipes.getLocalConss.Model.addExprNonlinear +pyscipopt.recipes.getLocalConss.Model.addMatrixCons +pyscipopt.recipes.getLocalConss.Model.addMatrixConsIndicator +pyscipopt.recipes.getLocalConss.Model.addMatrixVar +pyscipopt.recipes.getLocalConss.Model.addObjoffset +pyscipopt.recipes.getLocalConss.Model.addPoolCut +pyscipopt.recipes.getLocalConss.Model.addPyCons +pyscipopt.recipes.getLocalConss.Model.addRowDive +pyscipopt.recipes.getLocalConss.Model.addRowExact +pyscipopt.recipes.getLocalConss.Model.addSol +pyscipopt.recipes.getLocalConss.Model.addVar +pyscipopt.recipes.getLocalConss.Model.addVarLocks +pyscipopt.recipes.getLocalConss.Model.addVarLocksType +pyscipopt.recipes.getLocalConss.Model.addVarSOS1 +pyscipopt.recipes.getLocalConss.Model.addVarSOS2 +pyscipopt.recipes.getLocalConss.Model.addVarToRow +pyscipopt.recipes.getLocalConss.Model.allColsInLP +pyscipopt.recipes.getLocalConss.Model.allowNegSlackExact +pyscipopt.recipes.getLocalConss.Model.appendVarSOS1 +pyscipopt.recipes.getLocalConss.Model.appendVarSOS2 +pyscipopt.recipes.getLocalConss.Model.applyCutsProbing +pyscipopt.recipes.getLocalConss.Model.attachEventHandlerCallback +pyscipopt.recipes.getLocalConss.Model.backtrackProbing +pyscipopt.recipes.getLocalConss.Model.branchLPExact +pyscipopt.recipes.getLocalConss.Model.branchVar +pyscipopt.recipes.getLocalConss.Model.branchVarVal +pyscipopt.recipes.getLocalConss.Model.cacheRowExtensions +pyscipopt.recipes.getLocalConss.Model.calcChildEstimate +pyscipopt.recipes.getLocalConss.Model.calcNodeselPriority +pyscipopt.recipes.getLocalConss.Model.catchEvent +pyscipopt.recipes.getLocalConss.Model.catchRowEvent +pyscipopt.recipes.getLocalConss.Model.catchVarEvent +pyscipopt.recipes.getLocalConss.Model.checkBendersSubproblemOptimality +pyscipopt.recipes.getLocalConss.Model.checkQuadraticNonlinear +pyscipopt.recipes.getLocalConss.Model.checkSol +pyscipopt.recipes.getLocalConss.Model.chgCapacityKnapsack +pyscipopt.recipes.getLocalConss.Model.chgCoefLinear +pyscipopt.recipes.getLocalConss.Model.chgLhs +pyscipopt.recipes.getLocalConss.Model.chgReoptObjective +pyscipopt.recipes.getLocalConss.Model.chgRhs +pyscipopt.recipes.getLocalConss.Model.chgRowLhsDive +pyscipopt.recipes.getLocalConss.Model.chgRowRhsDive +pyscipopt.recipes.getLocalConss.Model.chgVarBranchPriority +pyscipopt.recipes.getLocalConss.Model.chgVarLb +pyscipopt.recipes.getLocalConss.Model.chgVarLbDive +pyscipopt.recipes.getLocalConss.Model.chgVarLbGlobal +pyscipopt.recipes.getLocalConss.Model.chgVarLbNode +pyscipopt.recipes.getLocalConss.Model.chgVarLbProbing +pyscipopt.recipes.getLocalConss.Model.chgVarObjDive +pyscipopt.recipes.getLocalConss.Model.chgVarObjProbing +pyscipopt.recipes.getLocalConss.Model.chgVarType +pyscipopt.recipes.getLocalConss.Model.chgVarUb +pyscipopt.recipes.getLocalConss.Model.chgVarUbDive +pyscipopt.recipes.getLocalConss.Model.chgVarUbGlobal +pyscipopt.recipes.getLocalConss.Model.chgVarUbNode +pyscipopt.recipes.getLocalConss.Model.chgVarUbProbing +pyscipopt.recipes.getLocalConss.Model.computeBestSolSubproblems +pyscipopt.recipes.getLocalConss.Model.constructLP +pyscipopt.recipes.getLocalConss.Model.copyLargeNeighborhoodSearch +pyscipopt.recipes.getLocalConss.Model.count +pyscipopt.recipes.getLocalConss.Model.createChild +pyscipopt.recipes.getLocalConss.Model.createCons +pyscipopt.recipes.getLocalConss.Model.createConsFromExpr +pyscipopt.recipes.getLocalConss.Model.createEmptyRowSepa +pyscipopt.recipes.getLocalConss.Model.createEmptyRowUnspec +pyscipopt.recipes.getLocalConss.Model.createOrigSol +pyscipopt.recipes.getLocalConss.Model.createPartialSol +pyscipopt.recipes.getLocalConss.Model.createProbBasic +pyscipopt.recipes.getLocalConss.Model.createSol +pyscipopt.recipes.getLocalConss.Model.cutoffNode +pyscipopt.recipes.getLocalConss.Model.deactivatePricer +pyscipopt.recipes.getLocalConss.Model.delCoefLinear +pyscipopt.recipes.getLocalConss.Model.delCons +pyscipopt.recipes.getLocalConss.Model.delConsLocal +pyscipopt.recipes.getLocalConss.Model.delVar +pyscipopt.recipes.getLocalConss.Model.disableDebugSol +pyscipopt.recipes.getLocalConss.Model.disablePropagation +pyscipopt.recipes.getLocalConss.Model.dropEvent +pyscipopt.recipes.getLocalConss.Model.dropRowEvent +pyscipopt.recipes.getLocalConss.Model.dropVarEvent +pyscipopt.recipes.getLocalConss.Model.enableDebugSol +pyscipopt.recipes.getLocalConss.Model.enableExactSolving +pyscipopt.recipes.getLocalConss.Model.enableReoptimization +pyscipopt.recipes.getLocalConss.Model.endDive +pyscipopt.recipes.getLocalConss.Model.endProbing +pyscipopt.recipes.getLocalConss.Model.endStrongbranch +pyscipopt.recipes.getLocalConss.Model.epsilon +pyscipopt.recipes.getLocalConss.Model.feasCeil +pyscipopt.recipes.getLocalConss.Model.feasFloor +pyscipopt.recipes.getLocalConss.Model.feasFrac +pyscipopt.recipes.getLocalConss.Model.feasRound +pyscipopt.recipes.getLocalConss.Model.feastol +pyscipopt.recipes.getLocalConss.Model.fixVar +pyscipopt.recipes.getLocalConss.Model.fixVarProbing +pyscipopt.recipes.getLocalConss.Model.flushRowExtensions +pyscipopt.recipes.getLocalConss.Model.frac +pyscipopt.recipes.getLocalConss.Model.freeBendersSubproblems +pyscipopt.recipes.getLocalConss.Model.freeProb +pyscipopt.recipes.getLocalConss.Model.freeReoptSolve +pyscipopt.recipes.getLocalConss.Model.freeSol +pyscipopt.recipes.getLocalConss.Model.freeTransform +pyscipopt.recipes.getLocalConss.Model.from_ptr +pyscipopt.recipes.getLocalConss.Model.generateIIS +pyscipopt.recipes.getLocalConss.Model.getActivity +pyscipopt.recipes.getLocalConss.Model.getBendersAuxiliaryVar +pyscipopt.recipes.getLocalConss.Model.getBendersSubproblem +pyscipopt.recipes.getLocalConss.Model.getBendersVar +pyscipopt.recipes.getLocalConss.Model.getBestChild +pyscipopt.recipes.getLocalConss.Model.getBestLeaf +pyscipopt.recipes.getLocalConss.Model.getBestNode +pyscipopt.recipes.getLocalConss.Model.getBestSibling +pyscipopt.recipes.getLocalConss.Model.getBestSol +pyscipopt.recipes.getLocalConss.Model.getBestboundNode +pyscipopt.recipes.getLocalConss.Model.getBipartiteGraphRepresentation +pyscipopt.recipes.getLocalConss.Model.getBranchScoreMultiple +pyscipopt.recipes.getLocalConss.Model.getCapacityKnapsack +pyscipopt.recipes.getLocalConss.Model.getChildren +pyscipopt.recipes.getLocalConss.Model.getColRedCost +pyscipopt.recipes.getLocalConss.Model.getCondition +pyscipopt.recipes.getLocalConss.Model.getConsNVars +pyscipopt.recipes.getLocalConss.Model.getConsVals +pyscipopt.recipes.getLocalConss.Model.getConsVars +pyscipopt.recipes.getLocalConss.Model.getConss +pyscipopt.recipes.getLocalConss.Model.getCurrentNode +pyscipopt.recipes.getLocalConss.Model.getCutEfficacy +pyscipopt.recipes.getLocalConss.Model.getCutLPSolCutoffDistance +pyscipopt.recipes.getLocalConss.Model.getCutoffbound +pyscipopt.recipes.getLocalConss.Model.getDepth +pyscipopt.recipes.getLocalConss.Model.getDualMultiplier +pyscipopt.recipes.getLocalConss.Model.getDualSolVal +pyscipopt.recipes.getLocalConss.Model.getDualbound +pyscipopt.recipes.getLocalConss.Model.getDualboundRoot +pyscipopt.recipes.getLocalConss.Model.getDualfarkasKnapsack +pyscipopt.recipes.getLocalConss.Model.getDualfarkasLinear +pyscipopt.recipes.getLocalConss.Model.getDualsolKnapsack +pyscipopt.recipes.getLocalConss.Model.getDualsolLinear +pyscipopt.recipes.getLocalConss.Model.getGap +pyscipopt.recipes.getLocalConss.Model.getHeurTiming +pyscipopt.recipes.getLocalConss.Model.getIIS +pyscipopt.recipes.getLocalConss.Model.getLPBInvARow +pyscipopt.recipes.getLocalConss.Model.getLPBInvRow +pyscipopt.recipes.getLocalConss.Model.getLPBasisInd +pyscipopt.recipes.getLocalConss.Model.getLPBranchCands +pyscipopt.recipes.getLocalConss.Model.getLPColsData +pyscipopt.recipes.getLocalConss.Model.getLPObjVal +pyscipopt.recipes.getLocalConss.Model.getLPRowsData +pyscipopt.recipes.getLocalConss.Model.getLPSolstat +pyscipopt.recipes.getLocalConss.Model.getLeaves +pyscipopt.recipes.getLocalConss.Model.getLhs +pyscipopt.recipes.getLocalConss.Model.getLinearConsIndicator +pyscipopt.recipes.getLocalConss.Model.getLocalEstimate +pyscipopt.recipes.getLocalConss.Model.getLowerbound +pyscipopt.recipes.getLocalConss.Model.getMajorVersion +pyscipopt.recipes.getLocalConss.Model.getMaxDepth +pyscipopt.recipes.getLocalConss.Model.getMinorVersion +pyscipopt.recipes.getLocalConss.Model.getNBestSolsFound +pyscipopt.recipes.getLocalConss.Model.getNBinVars +pyscipopt.recipes.getLocalConss.Model.getNChildren +pyscipopt.recipes.getLocalConss.Model.getNConss +pyscipopt.recipes.getLocalConss.Model.getNContVars +pyscipopt.recipes.getLocalConss.Model.getNCountedSols +pyscipopt.recipes.getLocalConss.Model.getNCuts +pyscipopt.recipes.getLocalConss.Model.getNCutsApplied +pyscipopt.recipes.getLocalConss.Model.getNFeasibleLeaves +pyscipopt.recipes.getLocalConss.Model.getNImplVars +pyscipopt.recipes.getLocalConss.Model.getNInfeasibleLeaves +pyscipopt.recipes.getLocalConss.Model.getNIntVars +pyscipopt.recipes.getLocalConss.Model.getNLPBranchCands +pyscipopt.recipes.getLocalConss.Model.getNLPCols +pyscipopt.recipes.getLocalConss.Model.getNLPIterations +pyscipopt.recipes.getLocalConss.Model.getNLPRows +pyscipopt.recipes.getLocalConss.Model.getNLPs +pyscipopt.recipes.getLocalConss.Model.getNLeaves +pyscipopt.recipes.getLocalConss.Model.getNLimSolsFound +pyscipopt.recipes.getLocalConss.Model.getNNlRows +pyscipopt.recipes.getLocalConss.Model.getNNodeLPIterations +pyscipopt.recipes.getLocalConss.Model.getNNodes +pyscipopt.recipes.getLocalConss.Model.getNReaders +pyscipopt.recipes.getLocalConss.Model.getNSepaRounds +pyscipopt.recipes.getLocalConss.Model.getNSiblings +pyscipopt.recipes.getLocalConss.Model.getNSols +pyscipopt.recipes.getLocalConss.Model.getNSolsFound +pyscipopt.recipes.getLocalConss.Model.getNStrongbranchLPIterations +pyscipopt.recipes.getLocalConss.Model.getNTotalNodes +pyscipopt.recipes.getLocalConss.Model.getNVars +pyscipopt.recipes.getLocalConss.Model.getNVarsAnd +pyscipopt.recipes.getLocalConss.Model.getNlRowActivityBounds +pyscipopt.recipes.getLocalConss.Model.getNlRowSolActivity +pyscipopt.recipes.getLocalConss.Model.getNlRowSolFeasibility +pyscipopt.recipes.getLocalConss.Model.getNlRows +pyscipopt.recipes.getLocalConss.Model.getObjVal +pyscipopt.recipes.getLocalConss.Model.getObjective +pyscipopt.recipes.getLocalConss.Model.getObjectiveSense +pyscipopt.recipes.getLocalConss.Model.getObjlimit +pyscipopt.recipes.getLocalConss.Model.getObjoffset +pyscipopt.recipes.getLocalConss.Model.getOpenNodes +pyscipopt.recipes.getLocalConss.Model.getParam +pyscipopt.recipes.getLocalConss.Model.getParams +pyscipopt.recipes.getLocalConss.Model.getPlungeDepth +pyscipopt.recipes.getLocalConss.Model.getPresolvingTime +pyscipopt.recipes.getLocalConss.Model.getPrimalRay +pyscipopt.recipes.getLocalConss.Model.getPrimalRayVal +pyscipopt.recipes.getLocalConss.Model.getPrimalbound +pyscipopt.recipes.getLocalConss.Model.getPrioChild +pyscipopt.recipes.getLocalConss.Model.getPrioSibling +pyscipopt.recipes.getLocalConss.Model.getProbName +pyscipopt.recipes.getLocalConss.Model.getProbingDepth +pyscipopt.recipes.getLocalConss.Model.getPseudoBranchCands +pyscipopt.recipes.getLocalConss.Model.getReadingTime +pyscipopt.recipes.getLocalConss.Model.getResultantAnd +pyscipopt.recipes.getLocalConss.Model.getRhs +pyscipopt.recipes.getLocalConss.Model.getRowActivity +pyscipopt.recipes.getLocalConss.Model.getRowDualSol +pyscipopt.recipes.getLocalConss.Model.getRowLPActivity +pyscipopt.recipes.getLocalConss.Model.getRowLinear +pyscipopt.recipes.getLocalConss.Model.getRowNumIntCols +pyscipopt.recipes.getLocalConss.Model.getRowObjParallelism +pyscipopt.recipes.getLocalConss.Model.getRowParallelism +pyscipopt.recipes.getLocalConss.Model.getSiblings +pyscipopt.recipes.getLocalConss.Model.getSlack +pyscipopt.recipes.getLocalConss.Model.getSlackVarIndicator +pyscipopt.recipes.getLocalConss.Model.getSolObjVal +pyscipopt.recipes.getLocalConss.Model.getSolTime +pyscipopt.recipes.getLocalConss.Model.getSolVal +pyscipopt.recipes.getLocalConss.Model.getSols +pyscipopt.recipes.getLocalConss.Model.getSolvingTime +pyscipopt.recipes.getLocalConss.Model.getStage +pyscipopt.recipes.getLocalConss.Model.getStageName +pyscipopt.recipes.getLocalConss.Model.getStatus +pyscipopt.recipes.getLocalConss.Model.getTechVersion +pyscipopt.recipes.getLocalConss.Model.getTermsQuadratic +pyscipopt.recipes.getLocalConss.Model.getTotalTime +pyscipopt.recipes.getLocalConss.Model.getTransformedCons +pyscipopt.recipes.getLocalConss.Model.getTransformedVar +pyscipopt.recipes.getLocalConss.Model.getTreesizeEstimation +pyscipopt.recipes.getLocalConss.Model.getVal +pyscipopt.recipes.getLocalConss.Model.getValsLinear +pyscipopt.recipes.getLocalConss.Model.getVarDict +pyscipopt.recipes.getLocalConss.Model.getVarLbDive +pyscipopt.recipes.getLocalConss.Model.getVarPseudocost +pyscipopt.recipes.getLocalConss.Model.getVarPseudocostScore +pyscipopt.recipes.getLocalConss.Model.getVarRedcost +pyscipopt.recipes.getLocalConss.Model.getVarStrongbranch +pyscipopt.recipes.getLocalConss.Model.getVarStrongbranchLast +pyscipopt.recipes.getLocalConss.Model.getVarStrongbranchNode +pyscipopt.recipes.getLocalConss.Model.getVarUbDive +pyscipopt.recipes.getLocalConss.Model.getVars +pyscipopt.recipes.getLocalConss.Model.getVarsAnd +pyscipopt.recipes.getLocalConss.Model.getWeightsKnapsack +pyscipopt.recipes.getLocalConss.Model.hasPrimalRay +pyscipopt.recipes.getLocalConss.Model.hideOutput +pyscipopt.recipes.getLocalConss.Model.inProbing +pyscipopt.recipes.getLocalConss.Model.inRepropagation +pyscipopt.recipes.getLocalConss.Model.includeBenders +pyscipopt.recipes.getLocalConss.Model.includeBendersDefaultCuts +pyscipopt.recipes.getLocalConss.Model.includeBenderscut +pyscipopt.recipes.getLocalConss.Model.includeBranchrule +pyscipopt.recipes.getLocalConss.Model.includeConshdlr +pyscipopt.recipes.getLocalConss.Model.includeCutsel +pyscipopt.recipes.getLocalConss.Model.includeDefaultPlugins +pyscipopt.recipes.getLocalConss.Model.includeEventhdlr +pyscipopt.recipes.getLocalConss.Model.includeHeur +pyscipopt.recipes.getLocalConss.Model.includeIISfinder +pyscipopt.recipes.getLocalConss.Model.includeNodesel +pyscipopt.recipes.getLocalConss.Model.includePresol +pyscipopt.recipes.getLocalConss.Model.includePricer +pyscipopt.recipes.getLocalConss.Model.includeProp +pyscipopt.recipes.getLocalConss.Model.includeReader +pyscipopt.recipes.getLocalConss.Model.includeRelax +pyscipopt.recipes.getLocalConss.Model.includeSepa +pyscipopt.recipes.getLocalConss.Model.infinity +pyscipopt.recipes.getLocalConss.Model.initBendersDefault +pyscipopt.recipes.getLocalConss.Model.interruptSolve +pyscipopt.recipes.getLocalConss.Model.isAndConsSorted +pyscipopt.recipes.getLocalConss.Model.isCutEfficacious +pyscipopt.recipes.getLocalConss.Model.isEQ +pyscipopt.recipes.getLocalConss.Model.isExact +pyscipopt.recipes.getLocalConss.Model.isFeasEQ +pyscipopt.recipes.getLocalConss.Model.isFeasGE +pyscipopt.recipes.getLocalConss.Model.isFeasGT +pyscipopt.recipes.getLocalConss.Model.isFeasIntegral +pyscipopt.recipes.getLocalConss.Model.isFeasLE +pyscipopt.recipes.getLocalConss.Model.isFeasLT +pyscipopt.recipes.getLocalConss.Model.isFeasNegative +pyscipopt.recipes.getLocalConss.Model.isFeasPositive +pyscipopt.recipes.getLocalConss.Model.isFeasZero +pyscipopt.recipes.getLocalConss.Model.isGE +pyscipopt.recipes.getLocalConss.Model.isGT +pyscipopt.recipes.getLocalConss.Model.isHugeValue +pyscipopt.recipes.getLocalConss.Model.isInfinity +pyscipopt.recipes.getLocalConss.Model.isLE +pyscipopt.recipes.getLocalConss.Model.isLPSolBasic +pyscipopt.recipes.getLocalConss.Model.isLT +pyscipopt.recipes.getLocalConss.Model.isNLPConstructed +pyscipopt.recipes.getLocalConss.Model.isNegative +pyscipopt.recipes.getLocalConss.Model.isObjChangedProbing +pyscipopt.recipes.getLocalConss.Model.isPositive +pyscipopt.recipes.getLocalConss.Model.isZero +pyscipopt.recipes.getLocalConss.Model.lpiGetIterations +pyscipopt.recipes.getLocalConss.Model.markDoNotAggrVar +pyscipopt.recipes.getLocalConss.Model.markDoNotMultaggrVar +pyscipopt.recipes.getLocalConss.Model.newProbingNode +pyscipopt.recipes.getLocalConss.Model.optimize +pyscipopt.recipes.getLocalConss.Model.optimizeNogil +pyscipopt.recipes.getLocalConss.Model.presolve +pyscipopt.recipes.getLocalConss.Model.printBestSol +pyscipopt.recipes.getLocalConss.Model.printCons +pyscipopt.recipes.getLocalConss.Model.printExternalCodeVersions +pyscipopt.recipes.getLocalConss.Model.printNlRow +pyscipopt.recipes.getLocalConss.Model.printProblem +pyscipopt.recipes.getLocalConss.Model.printRow +pyscipopt.recipes.getLocalConss.Model.printSol +pyscipopt.recipes.getLocalConss.Model.printStatistics +pyscipopt.recipes.getLocalConss.Model.printStatisticsJson +pyscipopt.recipes.getLocalConss.Model.printVersion +pyscipopt.recipes.getLocalConss.Model.propagateProbing +pyscipopt.recipes.getLocalConss.Model.readParams +pyscipopt.recipes.getLocalConss.Model.readProblem +pyscipopt.recipes.getLocalConss.Model.readSol +pyscipopt.recipes.getLocalConss.Model.readSolFile +pyscipopt.recipes.getLocalConss.Model.redirectOutput +pyscipopt.recipes.getLocalConss.Model.relax +pyscipopt.recipes.getLocalConss.Model.releaseRow +pyscipopt.recipes.getLocalConss.Model.repropagateNode +pyscipopt.recipes.getLocalConss.Model.resetParam +pyscipopt.recipes.getLocalConss.Model.resetParams +pyscipopt.recipes.getLocalConss.Model.restartSolve +pyscipopt.recipes.getLocalConss.Model.separateSol +pyscipopt.recipes.getLocalConss.Model.setBendersSubproblemIsConvex +pyscipopt.recipes.getLocalConss.Model.setBoolParam +pyscipopt.recipes.getLocalConss.Model.setCharParam +pyscipopt.recipes.getLocalConss.Model.setCheck +pyscipopt.recipes.getLocalConss.Model.setEmphasis +pyscipopt.recipes.getLocalConss.Model.setEnforced +pyscipopt.recipes.getLocalConss.Model.setHeurTiming +pyscipopt.recipes.getLocalConss.Model.setHeuristics +pyscipopt.recipes.getLocalConss.Model.setInitial +pyscipopt.recipes.getLocalConss.Model.setIntParam +pyscipopt.recipes.getLocalConss.Model.setLogfile +pyscipopt.recipes.getLocalConss.Model.setLongintParam +pyscipopt.recipes.getLocalConss.Model.setMaximize +pyscipopt.recipes.getLocalConss.Model.setMinimize +pyscipopt.recipes.getLocalConss.Model.setModifiable +pyscipopt.recipes.getLocalConss.Model.setObjIntegral +pyscipopt.recipes.getLocalConss.Model.setObjective +pyscipopt.recipes.getLocalConss.Model.setObjlimit +pyscipopt.recipes.getLocalConss.Model.setParam +pyscipopt.recipes.getLocalConss.Model.setParams +pyscipopt.recipes.getLocalConss.Model.setParamsCountsols +pyscipopt.recipes.getLocalConss.Model.setPresolve +pyscipopt.recipes.getLocalConss.Model.setProbName +pyscipopt.recipes.getLocalConss.Model.setRealParam +pyscipopt.recipes.getLocalConss.Model.setRelaxSolVal +pyscipopt.recipes.getLocalConss.Model.setRemovable +pyscipopt.recipes.getLocalConss.Model.setSeparating +pyscipopt.recipes.getLocalConss.Model.setSolVal +pyscipopt.recipes.getLocalConss.Model.setStringParam +pyscipopt.recipes.getLocalConss.Model.setupBendersSubproblem +pyscipopt.recipes.getLocalConss.Model.solveBendersSubproblem +pyscipopt.recipes.getLocalConss.Model.solveConcurrent +pyscipopt.recipes.getLocalConss.Model.solveDiveLP +pyscipopt.recipes.getLocalConss.Model.solveProbingLP +pyscipopt.recipes.getLocalConss.Model.sortAndCons +pyscipopt.recipes.getLocalConss.Model.startDive +pyscipopt.recipes.getLocalConss.Model.startProbing +pyscipopt.recipes.getLocalConss.Model.startStrongbranch +pyscipopt.recipes.getLocalConss.Model.tightenVarLb +pyscipopt.recipes.getLocalConss.Model.tightenVarLbGlobal +pyscipopt.recipes.getLocalConss.Model.tightenVarUb +pyscipopt.recipes.getLocalConss.Model.tightenVarUbGlobal +pyscipopt.recipes.getLocalConss.Model.to_ptr +pyscipopt.recipes.getLocalConss.Model.translateSubSol +pyscipopt.recipes.getLocalConss.Model.trySol +pyscipopt.recipes.getLocalConss.Model.updateBendersLowerbounds +pyscipopt.recipes.getLocalConss.Model.updateNodeLowerbound +pyscipopt.recipes.getLocalConss.Model.updateVarPseudocost +pyscipopt.recipes.getLocalConss.Model.version +pyscipopt.recipes.getLocalConss.Model.writeBestSol +pyscipopt.recipes.getLocalConss.Model.writeBestTransSol +pyscipopt.recipes.getLocalConss.Model.writeLP +pyscipopt.recipes.getLocalConss.Model.writeMIP +pyscipopt.recipes.getLocalConss.Model.writeName +pyscipopt.recipes.getLocalConss.Model.writeParams +pyscipopt.recipes.getLocalConss.Model.writeProblem +pyscipopt.recipes.getLocalConss.Model.writeSol +pyscipopt.recipes.getLocalConss.Model.writeStatistics +pyscipopt.recipes.getLocalConss.Model.writeStatisticsJson +pyscipopt.recipes.getLocalConss.Model.writeTransSol +pyscipopt.recipes.infeasibilities.Model +pyscipopt.recipes.infeasibilities.Model._createConsGenNonlinear +pyscipopt.recipes.infeasibilities.Model._createConsLinear +pyscipopt.recipes.infeasibilities.Model._createConsNonlinear +pyscipopt.recipes.infeasibilities.Model._createConsQuadratic +pyscipopt.recipes.infeasibilities.Model._getStageNames +pyscipopt.recipes.infeasibilities.Model.activateBenders +pyscipopt.recipes.infeasibilities.Model.addBendersSubproblem +pyscipopt.recipes.infeasibilities.Model.addCoefKnapsack +pyscipopt.recipes.infeasibilities.Model.addCoefLinear +pyscipopt.recipes.infeasibilities.Model.addCons +pyscipopt.recipes.infeasibilities.Model.addConsAnd +pyscipopt.recipes.infeasibilities.Model.addConsCardinality +pyscipopt.recipes.infeasibilities.Model.addConsCoeff +pyscipopt.recipes.infeasibilities.Model.addConsDisjunction +pyscipopt.recipes.infeasibilities.Model.addConsElemDisjunction +pyscipopt.recipes.infeasibilities.Model.addConsIndicator +pyscipopt.recipes.infeasibilities.Model.addConsKnapsack +pyscipopt.recipes.infeasibilities.Model.addConsLocal +pyscipopt.recipes.infeasibilities.Model.addConsNode +pyscipopt.recipes.infeasibilities.Model.addConsOr +pyscipopt.recipes.infeasibilities.Model.addConsSOS1 +pyscipopt.recipes.infeasibilities.Model.addConsSOS2 +pyscipopt.recipes.infeasibilities.Model.addConsXor +pyscipopt.recipes.infeasibilities.Model.addConss +pyscipopt.recipes.infeasibilities.Model.addCut +pyscipopt.recipes.infeasibilities.Model.addExprNonlinear +pyscipopt.recipes.infeasibilities.Model.addMatrixCons +pyscipopt.recipes.infeasibilities.Model.addMatrixConsIndicator +pyscipopt.recipes.infeasibilities.Model.addMatrixVar +pyscipopt.recipes.infeasibilities.Model.addObjoffset +pyscipopt.recipes.infeasibilities.Model.addPoolCut +pyscipopt.recipes.infeasibilities.Model.addPyCons +pyscipopt.recipes.infeasibilities.Model.addRowDive +pyscipopt.recipes.infeasibilities.Model.addRowExact +pyscipopt.recipes.infeasibilities.Model.addSol +pyscipopt.recipes.infeasibilities.Model.addVar +pyscipopt.recipes.infeasibilities.Model.addVarLocks +pyscipopt.recipes.infeasibilities.Model.addVarLocksType +pyscipopt.recipes.infeasibilities.Model.addVarSOS1 +pyscipopt.recipes.infeasibilities.Model.addVarSOS2 +pyscipopt.recipes.infeasibilities.Model.addVarToRow +pyscipopt.recipes.infeasibilities.Model.allColsInLP +pyscipopt.recipes.infeasibilities.Model.allowNegSlackExact +pyscipopt.recipes.infeasibilities.Model.appendVarSOS1 +pyscipopt.recipes.infeasibilities.Model.appendVarSOS2 +pyscipopt.recipes.infeasibilities.Model.applyCutsProbing +pyscipopt.recipes.infeasibilities.Model.attachEventHandlerCallback +pyscipopt.recipes.infeasibilities.Model.backtrackProbing +pyscipopt.recipes.infeasibilities.Model.branchLPExact +pyscipopt.recipes.infeasibilities.Model.branchVar +pyscipopt.recipes.infeasibilities.Model.branchVarVal +pyscipopt.recipes.infeasibilities.Model.cacheRowExtensions +pyscipopt.recipes.infeasibilities.Model.calcChildEstimate +pyscipopt.recipes.infeasibilities.Model.calcNodeselPriority +pyscipopt.recipes.infeasibilities.Model.catchEvent +pyscipopt.recipes.infeasibilities.Model.catchRowEvent +pyscipopt.recipes.infeasibilities.Model.catchVarEvent +pyscipopt.recipes.infeasibilities.Model.checkBendersSubproblemOptimality +pyscipopt.recipes.infeasibilities.Model.checkQuadraticNonlinear +pyscipopt.recipes.infeasibilities.Model.checkSol +pyscipopt.recipes.infeasibilities.Model.chgCapacityKnapsack +pyscipopt.recipes.infeasibilities.Model.chgCoefLinear +pyscipopt.recipes.infeasibilities.Model.chgLhs +pyscipopt.recipes.infeasibilities.Model.chgReoptObjective +pyscipopt.recipes.infeasibilities.Model.chgRhs +pyscipopt.recipes.infeasibilities.Model.chgRowLhsDive +pyscipopt.recipes.infeasibilities.Model.chgRowRhsDive +pyscipopt.recipes.infeasibilities.Model.chgVarBranchPriority +pyscipopt.recipes.infeasibilities.Model.chgVarLb +pyscipopt.recipes.infeasibilities.Model.chgVarLbDive +pyscipopt.recipes.infeasibilities.Model.chgVarLbGlobal +pyscipopt.recipes.infeasibilities.Model.chgVarLbNode +pyscipopt.recipes.infeasibilities.Model.chgVarLbProbing +pyscipopt.recipes.infeasibilities.Model.chgVarObjDive +pyscipopt.recipes.infeasibilities.Model.chgVarObjProbing +pyscipopt.recipes.infeasibilities.Model.chgVarType +pyscipopt.recipes.infeasibilities.Model.chgVarUb +pyscipopt.recipes.infeasibilities.Model.chgVarUbDive +pyscipopt.recipes.infeasibilities.Model.chgVarUbGlobal +pyscipopt.recipes.infeasibilities.Model.chgVarUbNode +pyscipopt.recipes.infeasibilities.Model.chgVarUbProbing +pyscipopt.recipes.infeasibilities.Model.computeBestSolSubproblems +pyscipopt.recipes.infeasibilities.Model.constructLP +pyscipopt.recipes.infeasibilities.Model.copyLargeNeighborhoodSearch +pyscipopt.recipes.infeasibilities.Model.count +pyscipopt.recipes.infeasibilities.Model.createChild +pyscipopt.recipes.infeasibilities.Model.createCons +pyscipopt.recipes.infeasibilities.Model.createConsFromExpr +pyscipopt.recipes.infeasibilities.Model.createEmptyRowSepa +pyscipopt.recipes.infeasibilities.Model.createEmptyRowUnspec +pyscipopt.recipes.infeasibilities.Model.createOrigSol +pyscipopt.recipes.infeasibilities.Model.createPartialSol +pyscipopt.recipes.infeasibilities.Model.createProbBasic +pyscipopt.recipes.infeasibilities.Model.createSol +pyscipopt.recipes.infeasibilities.Model.cutoffNode +pyscipopt.recipes.infeasibilities.Model.deactivatePricer +pyscipopt.recipes.infeasibilities.Model.delCoefLinear +pyscipopt.recipes.infeasibilities.Model.delCons +pyscipopt.recipes.infeasibilities.Model.delConsLocal +pyscipopt.recipes.infeasibilities.Model.delVar +pyscipopt.recipes.infeasibilities.Model.disableDebugSol +pyscipopt.recipes.infeasibilities.Model.disablePropagation +pyscipopt.recipes.infeasibilities.Model.dropEvent +pyscipopt.recipes.infeasibilities.Model.dropRowEvent +pyscipopt.recipes.infeasibilities.Model.dropVarEvent +pyscipopt.recipes.infeasibilities.Model.enableDebugSol +pyscipopt.recipes.infeasibilities.Model.enableExactSolving +pyscipopt.recipes.infeasibilities.Model.enableReoptimization +pyscipopt.recipes.infeasibilities.Model.endDive +pyscipopt.recipes.infeasibilities.Model.endProbing +pyscipopt.recipes.infeasibilities.Model.endStrongbranch +pyscipopt.recipes.infeasibilities.Model.epsilon +pyscipopt.recipes.infeasibilities.Model.feasCeil +pyscipopt.recipes.infeasibilities.Model.feasFloor +pyscipopt.recipes.infeasibilities.Model.feasFrac +pyscipopt.recipes.infeasibilities.Model.feasRound +pyscipopt.recipes.infeasibilities.Model.feastol +pyscipopt.recipes.infeasibilities.Model.fixVar +pyscipopt.recipes.infeasibilities.Model.fixVarProbing +pyscipopt.recipes.infeasibilities.Model.flushRowExtensions +pyscipopt.recipes.infeasibilities.Model.frac +pyscipopt.recipes.infeasibilities.Model.freeBendersSubproblems +pyscipopt.recipes.infeasibilities.Model.freeProb +pyscipopt.recipes.infeasibilities.Model.freeReoptSolve +pyscipopt.recipes.infeasibilities.Model.freeSol +pyscipopt.recipes.infeasibilities.Model.freeTransform +pyscipopt.recipes.infeasibilities.Model.from_ptr +pyscipopt.recipes.infeasibilities.Model.generateIIS +pyscipopt.recipes.infeasibilities.Model.getActivity +pyscipopt.recipes.infeasibilities.Model.getBendersAuxiliaryVar +pyscipopt.recipes.infeasibilities.Model.getBendersSubproblem +pyscipopt.recipes.infeasibilities.Model.getBendersVar +pyscipopt.recipes.infeasibilities.Model.getBestChild +pyscipopt.recipes.infeasibilities.Model.getBestLeaf +pyscipopt.recipes.infeasibilities.Model.getBestNode +pyscipopt.recipes.infeasibilities.Model.getBestSibling +pyscipopt.recipes.infeasibilities.Model.getBestSol +pyscipopt.recipes.infeasibilities.Model.getBestboundNode +pyscipopt.recipes.infeasibilities.Model.getBipartiteGraphRepresentation +pyscipopt.recipes.infeasibilities.Model.getBranchScoreMultiple +pyscipopt.recipes.infeasibilities.Model.getCapacityKnapsack +pyscipopt.recipes.infeasibilities.Model.getChildren +pyscipopt.recipes.infeasibilities.Model.getColRedCost +pyscipopt.recipes.infeasibilities.Model.getCondition +pyscipopt.recipes.infeasibilities.Model.getConsNVars +pyscipopt.recipes.infeasibilities.Model.getConsVals +pyscipopt.recipes.infeasibilities.Model.getConsVars +pyscipopt.recipes.infeasibilities.Model.getConss +pyscipopt.recipes.infeasibilities.Model.getCurrentNode +pyscipopt.recipes.infeasibilities.Model.getCutEfficacy +pyscipopt.recipes.infeasibilities.Model.getCutLPSolCutoffDistance +pyscipopt.recipes.infeasibilities.Model.getCutoffbound +pyscipopt.recipes.infeasibilities.Model.getDepth +pyscipopt.recipes.infeasibilities.Model.getDualMultiplier +pyscipopt.recipes.infeasibilities.Model.getDualSolVal +pyscipopt.recipes.infeasibilities.Model.getDualbound +pyscipopt.recipes.infeasibilities.Model.getDualboundRoot +pyscipopt.recipes.infeasibilities.Model.getDualfarkasKnapsack +pyscipopt.recipes.infeasibilities.Model.getDualfarkasLinear +pyscipopt.recipes.infeasibilities.Model.getDualsolKnapsack +pyscipopt.recipes.infeasibilities.Model.getDualsolLinear +pyscipopt.recipes.infeasibilities.Model.getGap +pyscipopt.recipes.infeasibilities.Model.getHeurTiming +pyscipopt.recipes.infeasibilities.Model.getIIS +pyscipopt.recipes.infeasibilities.Model.getLPBInvARow +pyscipopt.recipes.infeasibilities.Model.getLPBInvRow +pyscipopt.recipes.infeasibilities.Model.getLPBasisInd +pyscipopt.recipes.infeasibilities.Model.getLPBranchCands +pyscipopt.recipes.infeasibilities.Model.getLPColsData +pyscipopt.recipes.infeasibilities.Model.getLPObjVal +pyscipopt.recipes.infeasibilities.Model.getLPRowsData +pyscipopt.recipes.infeasibilities.Model.getLPSolstat +pyscipopt.recipes.infeasibilities.Model.getLeaves +pyscipopt.recipes.infeasibilities.Model.getLhs +pyscipopt.recipes.infeasibilities.Model.getLinearConsIndicator +pyscipopt.recipes.infeasibilities.Model.getLocalEstimate +pyscipopt.recipes.infeasibilities.Model.getLowerbound +pyscipopt.recipes.infeasibilities.Model.getMajorVersion +pyscipopt.recipes.infeasibilities.Model.getMaxDepth +pyscipopt.recipes.infeasibilities.Model.getMinorVersion +pyscipopt.recipes.infeasibilities.Model.getNBestSolsFound +pyscipopt.recipes.infeasibilities.Model.getNBinVars +pyscipopt.recipes.infeasibilities.Model.getNChildren +pyscipopt.recipes.infeasibilities.Model.getNConss +pyscipopt.recipes.infeasibilities.Model.getNContVars +pyscipopt.recipes.infeasibilities.Model.getNCountedSols +pyscipopt.recipes.infeasibilities.Model.getNCuts +pyscipopt.recipes.infeasibilities.Model.getNCutsApplied +pyscipopt.recipes.infeasibilities.Model.getNFeasibleLeaves +pyscipopt.recipes.infeasibilities.Model.getNImplVars +pyscipopt.recipes.infeasibilities.Model.getNInfeasibleLeaves +pyscipopt.recipes.infeasibilities.Model.getNIntVars +pyscipopt.recipes.infeasibilities.Model.getNLPBranchCands +pyscipopt.recipes.infeasibilities.Model.getNLPCols +pyscipopt.recipes.infeasibilities.Model.getNLPIterations +pyscipopt.recipes.infeasibilities.Model.getNLPRows +pyscipopt.recipes.infeasibilities.Model.getNLPs +pyscipopt.recipes.infeasibilities.Model.getNLeaves +pyscipopt.recipes.infeasibilities.Model.getNLimSolsFound +pyscipopt.recipes.infeasibilities.Model.getNNlRows +pyscipopt.recipes.infeasibilities.Model.getNNodeLPIterations +pyscipopt.recipes.infeasibilities.Model.getNNodes +pyscipopt.recipes.infeasibilities.Model.getNReaders +pyscipopt.recipes.infeasibilities.Model.getNSepaRounds +pyscipopt.recipes.infeasibilities.Model.getNSiblings +pyscipopt.recipes.infeasibilities.Model.getNSols +pyscipopt.recipes.infeasibilities.Model.getNSolsFound +pyscipopt.recipes.infeasibilities.Model.getNStrongbranchLPIterations +pyscipopt.recipes.infeasibilities.Model.getNTotalNodes +pyscipopt.recipes.infeasibilities.Model.getNVars +pyscipopt.recipes.infeasibilities.Model.getNVarsAnd +pyscipopt.recipes.infeasibilities.Model.getNlRowActivityBounds +pyscipopt.recipes.infeasibilities.Model.getNlRowSolActivity +pyscipopt.recipes.infeasibilities.Model.getNlRowSolFeasibility +pyscipopt.recipes.infeasibilities.Model.getNlRows +pyscipopt.recipes.infeasibilities.Model.getObjVal +pyscipopt.recipes.infeasibilities.Model.getObjective +pyscipopt.recipes.infeasibilities.Model.getObjectiveSense +pyscipopt.recipes.infeasibilities.Model.getObjlimit +pyscipopt.recipes.infeasibilities.Model.getObjoffset +pyscipopt.recipes.infeasibilities.Model.getOpenNodes +pyscipopt.recipes.infeasibilities.Model.getParam +pyscipopt.recipes.infeasibilities.Model.getParams +pyscipopt.recipes.infeasibilities.Model.getPlungeDepth +pyscipopt.recipes.infeasibilities.Model.getPresolvingTime +pyscipopt.recipes.infeasibilities.Model.getPrimalRay +pyscipopt.recipes.infeasibilities.Model.getPrimalRayVal +pyscipopt.recipes.infeasibilities.Model.getPrimalbound +pyscipopt.recipes.infeasibilities.Model.getPrioChild +pyscipopt.recipes.infeasibilities.Model.getPrioSibling +pyscipopt.recipes.infeasibilities.Model.getProbName +pyscipopt.recipes.infeasibilities.Model.getProbingDepth +pyscipopt.recipes.infeasibilities.Model.getPseudoBranchCands +pyscipopt.recipes.infeasibilities.Model.getReadingTime +pyscipopt.recipes.infeasibilities.Model.getResultantAnd +pyscipopt.recipes.infeasibilities.Model.getRhs +pyscipopt.recipes.infeasibilities.Model.getRowActivity +pyscipopt.recipes.infeasibilities.Model.getRowDualSol +pyscipopt.recipes.infeasibilities.Model.getRowLPActivity +pyscipopt.recipes.infeasibilities.Model.getRowLinear +pyscipopt.recipes.infeasibilities.Model.getRowNumIntCols +pyscipopt.recipes.infeasibilities.Model.getRowObjParallelism +pyscipopt.recipes.infeasibilities.Model.getRowParallelism +pyscipopt.recipes.infeasibilities.Model.getSiblings +pyscipopt.recipes.infeasibilities.Model.getSlack +pyscipopt.recipes.infeasibilities.Model.getSlackVarIndicator +pyscipopt.recipes.infeasibilities.Model.getSolObjVal +pyscipopt.recipes.infeasibilities.Model.getSolTime +pyscipopt.recipes.infeasibilities.Model.getSolVal +pyscipopt.recipes.infeasibilities.Model.getSols +pyscipopt.recipes.infeasibilities.Model.getSolvingTime +pyscipopt.recipes.infeasibilities.Model.getStage +pyscipopt.recipes.infeasibilities.Model.getStageName +pyscipopt.recipes.infeasibilities.Model.getStatus +pyscipopt.recipes.infeasibilities.Model.getTechVersion +pyscipopt.recipes.infeasibilities.Model.getTermsQuadratic +pyscipopt.recipes.infeasibilities.Model.getTotalTime +pyscipopt.recipes.infeasibilities.Model.getTransformedCons +pyscipopt.recipes.infeasibilities.Model.getTransformedVar +pyscipopt.recipes.infeasibilities.Model.getTreesizeEstimation +pyscipopt.recipes.infeasibilities.Model.getVal +pyscipopt.recipes.infeasibilities.Model.getValsLinear +pyscipopt.recipes.infeasibilities.Model.getVarDict +pyscipopt.recipes.infeasibilities.Model.getVarLbDive +pyscipopt.recipes.infeasibilities.Model.getVarPseudocost +pyscipopt.recipes.infeasibilities.Model.getVarPseudocostScore +pyscipopt.recipes.infeasibilities.Model.getVarRedcost +pyscipopt.recipes.infeasibilities.Model.getVarStrongbranch +pyscipopt.recipes.infeasibilities.Model.getVarStrongbranchLast +pyscipopt.recipes.infeasibilities.Model.getVarStrongbranchNode +pyscipopt.recipes.infeasibilities.Model.getVarUbDive +pyscipopt.recipes.infeasibilities.Model.getVars +pyscipopt.recipes.infeasibilities.Model.getVarsAnd +pyscipopt.recipes.infeasibilities.Model.getWeightsKnapsack +pyscipopt.recipes.infeasibilities.Model.hasPrimalRay +pyscipopt.recipes.infeasibilities.Model.hideOutput +pyscipopt.recipes.infeasibilities.Model.inProbing +pyscipopt.recipes.infeasibilities.Model.inRepropagation +pyscipopt.recipes.infeasibilities.Model.includeBenders +pyscipopt.recipes.infeasibilities.Model.includeBendersDefaultCuts +pyscipopt.recipes.infeasibilities.Model.includeBenderscut +pyscipopt.recipes.infeasibilities.Model.includeBranchrule +pyscipopt.recipes.infeasibilities.Model.includeConshdlr +pyscipopt.recipes.infeasibilities.Model.includeCutsel +pyscipopt.recipes.infeasibilities.Model.includeDefaultPlugins +pyscipopt.recipes.infeasibilities.Model.includeEventhdlr +pyscipopt.recipes.infeasibilities.Model.includeHeur +pyscipopt.recipes.infeasibilities.Model.includeIISfinder +pyscipopt.recipes.infeasibilities.Model.includeNodesel +pyscipopt.recipes.infeasibilities.Model.includePresol +pyscipopt.recipes.infeasibilities.Model.includePricer +pyscipopt.recipes.infeasibilities.Model.includeProp +pyscipopt.recipes.infeasibilities.Model.includeReader +pyscipopt.recipes.infeasibilities.Model.includeRelax +pyscipopt.recipes.infeasibilities.Model.includeSepa +pyscipopt.recipes.infeasibilities.Model.infinity +pyscipopt.recipes.infeasibilities.Model.initBendersDefault +pyscipopt.recipes.infeasibilities.Model.interruptSolve +pyscipopt.recipes.infeasibilities.Model.isAndConsSorted +pyscipopt.recipes.infeasibilities.Model.isCutEfficacious +pyscipopt.recipes.infeasibilities.Model.isEQ +pyscipopt.recipes.infeasibilities.Model.isExact +pyscipopt.recipes.infeasibilities.Model.isFeasEQ +pyscipopt.recipes.infeasibilities.Model.isFeasGE +pyscipopt.recipes.infeasibilities.Model.isFeasGT +pyscipopt.recipes.infeasibilities.Model.isFeasIntegral +pyscipopt.recipes.infeasibilities.Model.isFeasLE +pyscipopt.recipes.infeasibilities.Model.isFeasLT +pyscipopt.recipes.infeasibilities.Model.isFeasNegative +pyscipopt.recipes.infeasibilities.Model.isFeasPositive +pyscipopt.recipes.infeasibilities.Model.isFeasZero +pyscipopt.recipes.infeasibilities.Model.isGE +pyscipopt.recipes.infeasibilities.Model.isGT +pyscipopt.recipes.infeasibilities.Model.isHugeValue +pyscipopt.recipes.infeasibilities.Model.isInfinity +pyscipopt.recipes.infeasibilities.Model.isLE +pyscipopt.recipes.infeasibilities.Model.isLPSolBasic +pyscipopt.recipes.infeasibilities.Model.isLT +pyscipopt.recipes.infeasibilities.Model.isNLPConstructed +pyscipopt.recipes.infeasibilities.Model.isNegative +pyscipopt.recipes.infeasibilities.Model.isObjChangedProbing +pyscipopt.recipes.infeasibilities.Model.isPositive +pyscipopt.recipes.infeasibilities.Model.isZero +pyscipopt.recipes.infeasibilities.Model.lpiGetIterations +pyscipopt.recipes.infeasibilities.Model.markDoNotAggrVar +pyscipopt.recipes.infeasibilities.Model.markDoNotMultaggrVar +pyscipopt.recipes.infeasibilities.Model.newProbingNode +pyscipopt.recipes.infeasibilities.Model.optimize +pyscipopt.recipes.infeasibilities.Model.optimizeNogil +pyscipopt.recipes.infeasibilities.Model.presolve +pyscipopt.recipes.infeasibilities.Model.printBestSol +pyscipopt.recipes.infeasibilities.Model.printCons +pyscipopt.recipes.infeasibilities.Model.printExternalCodeVersions +pyscipopt.recipes.infeasibilities.Model.printNlRow +pyscipopt.recipes.infeasibilities.Model.printProblem +pyscipopt.recipes.infeasibilities.Model.printRow +pyscipopt.recipes.infeasibilities.Model.printSol +pyscipopt.recipes.infeasibilities.Model.printStatistics +pyscipopt.recipes.infeasibilities.Model.printStatisticsJson +pyscipopt.recipes.infeasibilities.Model.printVersion +pyscipopt.recipes.infeasibilities.Model.propagateProbing +pyscipopt.recipes.infeasibilities.Model.readParams +pyscipopt.recipes.infeasibilities.Model.readProblem +pyscipopt.recipes.infeasibilities.Model.readSol +pyscipopt.recipes.infeasibilities.Model.readSolFile +pyscipopt.recipes.infeasibilities.Model.redirectOutput +pyscipopt.recipes.infeasibilities.Model.relax +pyscipopt.recipes.infeasibilities.Model.releaseRow +pyscipopt.recipes.infeasibilities.Model.repropagateNode +pyscipopt.recipes.infeasibilities.Model.resetParam +pyscipopt.recipes.infeasibilities.Model.resetParams +pyscipopt.recipes.infeasibilities.Model.restartSolve +pyscipopt.recipes.infeasibilities.Model.separateSol +pyscipopt.recipes.infeasibilities.Model.setBendersSubproblemIsConvex +pyscipopt.recipes.infeasibilities.Model.setBoolParam +pyscipopt.recipes.infeasibilities.Model.setCharParam +pyscipopt.recipes.infeasibilities.Model.setCheck +pyscipopt.recipes.infeasibilities.Model.setEmphasis +pyscipopt.recipes.infeasibilities.Model.setEnforced +pyscipopt.recipes.infeasibilities.Model.setHeurTiming +pyscipopt.recipes.infeasibilities.Model.setHeuristics +pyscipopt.recipes.infeasibilities.Model.setInitial +pyscipopt.recipes.infeasibilities.Model.setIntParam +pyscipopt.recipes.infeasibilities.Model.setLogfile +pyscipopt.recipes.infeasibilities.Model.setLongintParam +pyscipopt.recipes.infeasibilities.Model.setMaximize +pyscipopt.recipes.infeasibilities.Model.setMinimize +pyscipopt.recipes.infeasibilities.Model.setModifiable +pyscipopt.recipes.infeasibilities.Model.setObjIntegral +pyscipopt.recipes.infeasibilities.Model.setObjective +pyscipopt.recipes.infeasibilities.Model.setObjlimit +pyscipopt.recipes.infeasibilities.Model.setParam +pyscipopt.recipes.infeasibilities.Model.setParams +pyscipopt.recipes.infeasibilities.Model.setParamsCountsols +pyscipopt.recipes.infeasibilities.Model.setPresolve +pyscipopt.recipes.infeasibilities.Model.setProbName +pyscipopt.recipes.infeasibilities.Model.setRealParam +pyscipopt.recipes.infeasibilities.Model.setRelaxSolVal +pyscipopt.recipes.infeasibilities.Model.setRemovable +pyscipopt.recipes.infeasibilities.Model.setSeparating +pyscipopt.recipes.infeasibilities.Model.setSolVal +pyscipopt.recipes.infeasibilities.Model.setStringParam +pyscipopt.recipes.infeasibilities.Model.setupBendersSubproblem +pyscipopt.recipes.infeasibilities.Model.solveBendersSubproblem +pyscipopt.recipes.infeasibilities.Model.solveConcurrent +pyscipopt.recipes.infeasibilities.Model.solveDiveLP +pyscipopt.recipes.infeasibilities.Model.solveProbingLP +pyscipopt.recipes.infeasibilities.Model.sortAndCons +pyscipopt.recipes.infeasibilities.Model.startDive +pyscipopt.recipes.infeasibilities.Model.startProbing +pyscipopt.recipes.infeasibilities.Model.startStrongbranch +pyscipopt.recipes.infeasibilities.Model.tightenVarLb +pyscipopt.recipes.infeasibilities.Model.tightenVarLbGlobal +pyscipopt.recipes.infeasibilities.Model.tightenVarUb +pyscipopt.recipes.infeasibilities.Model.tightenVarUbGlobal +pyscipopt.recipes.infeasibilities.Model.to_ptr +pyscipopt.recipes.infeasibilities.Model.translateSubSol +pyscipopt.recipes.infeasibilities.Model.trySol +pyscipopt.recipes.infeasibilities.Model.updateBendersLowerbounds +pyscipopt.recipes.infeasibilities.Model.updateNodeLowerbound +pyscipopt.recipes.infeasibilities.Model.updateVarPseudocost +pyscipopt.recipes.infeasibilities.Model.version +pyscipopt.recipes.infeasibilities.Model.writeBestSol +pyscipopt.recipes.infeasibilities.Model.writeBestTransSol +pyscipopt.recipes.infeasibilities.Model.writeLP +pyscipopt.recipes.infeasibilities.Model.writeMIP +pyscipopt.recipes.infeasibilities.Model.writeName +pyscipopt.recipes.infeasibilities.Model.writeParams +pyscipopt.recipes.infeasibilities.Model.writeProblem +pyscipopt.recipes.infeasibilities.Model.writeSol +pyscipopt.recipes.infeasibilities.Model.writeStatistics +pyscipopt.recipes.infeasibilities.Model.writeStatisticsJson +pyscipopt.recipes.infeasibilities.Model.writeTransSol +pyscipopt.recipes.nonlinear.Model +pyscipopt.recipes.nonlinear.Model._createConsGenNonlinear +pyscipopt.recipes.nonlinear.Model._createConsLinear +pyscipopt.recipes.nonlinear.Model._createConsNonlinear +pyscipopt.recipes.nonlinear.Model._createConsQuadratic +pyscipopt.recipes.nonlinear.Model._getStageNames +pyscipopt.recipes.nonlinear.Model.activateBenders +pyscipopt.recipes.nonlinear.Model.addBendersSubproblem +pyscipopt.recipes.nonlinear.Model.addCoefKnapsack +pyscipopt.recipes.nonlinear.Model.addCoefLinear +pyscipopt.recipes.nonlinear.Model.addCons +pyscipopt.recipes.nonlinear.Model.addConsAnd +pyscipopt.recipes.nonlinear.Model.addConsCardinality +pyscipopt.recipes.nonlinear.Model.addConsCoeff +pyscipopt.recipes.nonlinear.Model.addConsDisjunction +pyscipopt.recipes.nonlinear.Model.addConsElemDisjunction +pyscipopt.recipes.nonlinear.Model.addConsIndicator +pyscipopt.recipes.nonlinear.Model.addConsKnapsack +pyscipopt.recipes.nonlinear.Model.addConsLocal +pyscipopt.recipes.nonlinear.Model.addConsNode +pyscipopt.recipes.nonlinear.Model.addConsOr +pyscipopt.recipes.nonlinear.Model.addConsSOS1 +pyscipopt.recipes.nonlinear.Model.addConsSOS2 +pyscipopt.recipes.nonlinear.Model.addConsXor +pyscipopt.recipes.nonlinear.Model.addConss +pyscipopt.recipes.nonlinear.Model.addCut +pyscipopt.recipes.nonlinear.Model.addExprNonlinear +pyscipopt.recipes.nonlinear.Model.addMatrixCons +pyscipopt.recipes.nonlinear.Model.addMatrixConsIndicator +pyscipopt.recipes.nonlinear.Model.addMatrixVar +pyscipopt.recipes.nonlinear.Model.addObjoffset +pyscipopt.recipes.nonlinear.Model.addPoolCut +pyscipopt.recipes.nonlinear.Model.addPyCons +pyscipopt.recipes.nonlinear.Model.addRowDive +pyscipopt.recipes.nonlinear.Model.addRowExact +pyscipopt.recipes.nonlinear.Model.addSol +pyscipopt.recipes.nonlinear.Model.addVar +pyscipopt.recipes.nonlinear.Model.addVarLocks +pyscipopt.recipes.nonlinear.Model.addVarLocksType +pyscipopt.recipes.nonlinear.Model.addVarSOS1 +pyscipopt.recipes.nonlinear.Model.addVarSOS2 +pyscipopt.recipes.nonlinear.Model.addVarToRow +pyscipopt.recipes.nonlinear.Model.allColsInLP +pyscipopt.recipes.nonlinear.Model.allowNegSlackExact +pyscipopt.recipes.nonlinear.Model.appendVarSOS1 +pyscipopt.recipes.nonlinear.Model.appendVarSOS2 +pyscipopt.recipes.nonlinear.Model.applyCutsProbing +pyscipopt.recipes.nonlinear.Model.attachEventHandlerCallback +pyscipopt.recipes.nonlinear.Model.backtrackProbing +pyscipopt.recipes.nonlinear.Model.branchLPExact +pyscipopt.recipes.nonlinear.Model.branchVar +pyscipopt.recipes.nonlinear.Model.branchVarVal +pyscipopt.recipes.nonlinear.Model.cacheRowExtensions +pyscipopt.recipes.nonlinear.Model.calcChildEstimate +pyscipopt.recipes.nonlinear.Model.calcNodeselPriority +pyscipopt.recipes.nonlinear.Model.catchEvent +pyscipopt.recipes.nonlinear.Model.catchRowEvent +pyscipopt.recipes.nonlinear.Model.catchVarEvent +pyscipopt.recipes.nonlinear.Model.checkBendersSubproblemOptimality +pyscipopt.recipes.nonlinear.Model.checkQuadraticNonlinear +pyscipopt.recipes.nonlinear.Model.checkSol +pyscipopt.recipes.nonlinear.Model.chgCapacityKnapsack +pyscipopt.recipes.nonlinear.Model.chgCoefLinear +pyscipopt.recipes.nonlinear.Model.chgLhs +pyscipopt.recipes.nonlinear.Model.chgReoptObjective +pyscipopt.recipes.nonlinear.Model.chgRhs +pyscipopt.recipes.nonlinear.Model.chgRowLhsDive +pyscipopt.recipes.nonlinear.Model.chgRowRhsDive +pyscipopt.recipes.nonlinear.Model.chgVarBranchPriority +pyscipopt.recipes.nonlinear.Model.chgVarLb +pyscipopt.recipes.nonlinear.Model.chgVarLbDive +pyscipopt.recipes.nonlinear.Model.chgVarLbGlobal +pyscipopt.recipes.nonlinear.Model.chgVarLbNode +pyscipopt.recipes.nonlinear.Model.chgVarLbProbing +pyscipopt.recipes.nonlinear.Model.chgVarObjDive +pyscipopt.recipes.nonlinear.Model.chgVarObjProbing +pyscipopt.recipes.nonlinear.Model.chgVarType +pyscipopt.recipes.nonlinear.Model.chgVarUb +pyscipopt.recipes.nonlinear.Model.chgVarUbDive +pyscipopt.recipes.nonlinear.Model.chgVarUbGlobal +pyscipopt.recipes.nonlinear.Model.chgVarUbNode +pyscipopt.recipes.nonlinear.Model.chgVarUbProbing +pyscipopt.recipes.nonlinear.Model.computeBestSolSubproblems +pyscipopt.recipes.nonlinear.Model.constructLP +pyscipopt.recipes.nonlinear.Model.copyLargeNeighborhoodSearch +pyscipopt.recipes.nonlinear.Model.count +pyscipopt.recipes.nonlinear.Model.createChild +pyscipopt.recipes.nonlinear.Model.createCons +pyscipopt.recipes.nonlinear.Model.createConsFromExpr +pyscipopt.recipes.nonlinear.Model.createEmptyRowSepa +pyscipopt.recipes.nonlinear.Model.createEmptyRowUnspec +pyscipopt.recipes.nonlinear.Model.createOrigSol +pyscipopt.recipes.nonlinear.Model.createPartialSol +pyscipopt.recipes.nonlinear.Model.createProbBasic +pyscipopt.recipes.nonlinear.Model.createSol +pyscipopt.recipes.nonlinear.Model.cutoffNode +pyscipopt.recipes.nonlinear.Model.deactivatePricer +pyscipopt.recipes.nonlinear.Model.delCoefLinear +pyscipopt.recipes.nonlinear.Model.delCons +pyscipopt.recipes.nonlinear.Model.delConsLocal +pyscipopt.recipes.nonlinear.Model.delVar +pyscipopt.recipes.nonlinear.Model.disableDebugSol +pyscipopt.recipes.nonlinear.Model.disablePropagation +pyscipopt.recipes.nonlinear.Model.dropEvent +pyscipopt.recipes.nonlinear.Model.dropRowEvent +pyscipopt.recipes.nonlinear.Model.dropVarEvent +pyscipopt.recipes.nonlinear.Model.enableDebugSol +pyscipopt.recipes.nonlinear.Model.enableExactSolving +pyscipopt.recipes.nonlinear.Model.enableReoptimization +pyscipopt.recipes.nonlinear.Model.endDive +pyscipopt.recipes.nonlinear.Model.endProbing +pyscipopt.recipes.nonlinear.Model.endStrongbranch +pyscipopt.recipes.nonlinear.Model.epsilon +pyscipopt.recipes.nonlinear.Model.feasCeil +pyscipopt.recipes.nonlinear.Model.feasFloor +pyscipopt.recipes.nonlinear.Model.feasFrac +pyscipopt.recipes.nonlinear.Model.feasRound +pyscipopt.recipes.nonlinear.Model.feastol +pyscipopt.recipes.nonlinear.Model.fixVar +pyscipopt.recipes.nonlinear.Model.fixVarProbing +pyscipopt.recipes.nonlinear.Model.flushRowExtensions +pyscipopt.recipes.nonlinear.Model.frac +pyscipopt.recipes.nonlinear.Model.freeBendersSubproblems +pyscipopt.recipes.nonlinear.Model.freeProb +pyscipopt.recipes.nonlinear.Model.freeReoptSolve +pyscipopt.recipes.nonlinear.Model.freeSol +pyscipopt.recipes.nonlinear.Model.freeTransform +pyscipopt.recipes.nonlinear.Model.from_ptr +pyscipopt.recipes.nonlinear.Model.generateIIS +pyscipopt.recipes.nonlinear.Model.getActivity +pyscipopt.recipes.nonlinear.Model.getBendersAuxiliaryVar +pyscipopt.recipes.nonlinear.Model.getBendersSubproblem +pyscipopt.recipes.nonlinear.Model.getBendersVar +pyscipopt.recipes.nonlinear.Model.getBestChild +pyscipopt.recipes.nonlinear.Model.getBestLeaf +pyscipopt.recipes.nonlinear.Model.getBestNode +pyscipopt.recipes.nonlinear.Model.getBestSibling +pyscipopt.recipes.nonlinear.Model.getBestSol +pyscipopt.recipes.nonlinear.Model.getBestboundNode +pyscipopt.recipes.nonlinear.Model.getBipartiteGraphRepresentation +pyscipopt.recipes.nonlinear.Model.getBranchScoreMultiple +pyscipopt.recipes.nonlinear.Model.getCapacityKnapsack +pyscipopt.recipes.nonlinear.Model.getChildren +pyscipopt.recipes.nonlinear.Model.getColRedCost +pyscipopt.recipes.nonlinear.Model.getCondition +pyscipopt.recipes.nonlinear.Model.getConsNVars +pyscipopt.recipes.nonlinear.Model.getConsVals +pyscipopt.recipes.nonlinear.Model.getConsVars +pyscipopt.recipes.nonlinear.Model.getConss +pyscipopt.recipes.nonlinear.Model.getCurrentNode +pyscipopt.recipes.nonlinear.Model.getCutEfficacy +pyscipopt.recipes.nonlinear.Model.getCutLPSolCutoffDistance +pyscipopt.recipes.nonlinear.Model.getCutoffbound +pyscipopt.recipes.nonlinear.Model.getDepth +pyscipopt.recipes.nonlinear.Model.getDualMultiplier +pyscipopt.recipes.nonlinear.Model.getDualSolVal +pyscipopt.recipes.nonlinear.Model.getDualbound +pyscipopt.recipes.nonlinear.Model.getDualboundRoot +pyscipopt.recipes.nonlinear.Model.getDualfarkasKnapsack +pyscipopt.recipes.nonlinear.Model.getDualfarkasLinear +pyscipopt.recipes.nonlinear.Model.getDualsolKnapsack +pyscipopt.recipes.nonlinear.Model.getDualsolLinear +pyscipopt.recipes.nonlinear.Model.getGap +pyscipopt.recipes.nonlinear.Model.getHeurTiming +pyscipopt.recipes.nonlinear.Model.getIIS +pyscipopt.recipes.nonlinear.Model.getLPBInvARow +pyscipopt.recipes.nonlinear.Model.getLPBInvRow +pyscipopt.recipes.nonlinear.Model.getLPBasisInd +pyscipopt.recipes.nonlinear.Model.getLPBranchCands +pyscipopt.recipes.nonlinear.Model.getLPColsData +pyscipopt.recipes.nonlinear.Model.getLPObjVal +pyscipopt.recipes.nonlinear.Model.getLPRowsData +pyscipopt.recipes.nonlinear.Model.getLPSolstat +pyscipopt.recipes.nonlinear.Model.getLeaves +pyscipopt.recipes.nonlinear.Model.getLhs +pyscipopt.recipes.nonlinear.Model.getLinearConsIndicator +pyscipopt.recipes.nonlinear.Model.getLocalEstimate +pyscipopt.recipes.nonlinear.Model.getLowerbound +pyscipopt.recipes.nonlinear.Model.getMajorVersion +pyscipopt.recipes.nonlinear.Model.getMaxDepth +pyscipopt.recipes.nonlinear.Model.getMinorVersion +pyscipopt.recipes.nonlinear.Model.getNBestSolsFound +pyscipopt.recipes.nonlinear.Model.getNBinVars +pyscipopt.recipes.nonlinear.Model.getNChildren +pyscipopt.recipes.nonlinear.Model.getNConss +pyscipopt.recipes.nonlinear.Model.getNContVars +pyscipopt.recipes.nonlinear.Model.getNCountedSols +pyscipopt.recipes.nonlinear.Model.getNCuts +pyscipopt.recipes.nonlinear.Model.getNCutsApplied +pyscipopt.recipes.nonlinear.Model.getNFeasibleLeaves +pyscipopt.recipes.nonlinear.Model.getNImplVars +pyscipopt.recipes.nonlinear.Model.getNInfeasibleLeaves +pyscipopt.recipes.nonlinear.Model.getNIntVars +pyscipopt.recipes.nonlinear.Model.getNLPBranchCands +pyscipopt.recipes.nonlinear.Model.getNLPCols +pyscipopt.recipes.nonlinear.Model.getNLPIterations +pyscipopt.recipes.nonlinear.Model.getNLPRows +pyscipopt.recipes.nonlinear.Model.getNLPs +pyscipopt.recipes.nonlinear.Model.getNLeaves +pyscipopt.recipes.nonlinear.Model.getNLimSolsFound +pyscipopt.recipes.nonlinear.Model.getNNlRows +pyscipopt.recipes.nonlinear.Model.getNNodeLPIterations +pyscipopt.recipes.nonlinear.Model.getNNodes +pyscipopt.recipes.nonlinear.Model.getNReaders +pyscipopt.recipes.nonlinear.Model.getNSepaRounds +pyscipopt.recipes.nonlinear.Model.getNSiblings +pyscipopt.recipes.nonlinear.Model.getNSols +pyscipopt.recipes.nonlinear.Model.getNSolsFound +pyscipopt.recipes.nonlinear.Model.getNStrongbranchLPIterations +pyscipopt.recipes.nonlinear.Model.getNTotalNodes +pyscipopt.recipes.nonlinear.Model.getNVars +pyscipopt.recipes.nonlinear.Model.getNVarsAnd +pyscipopt.recipes.nonlinear.Model.getNlRowActivityBounds +pyscipopt.recipes.nonlinear.Model.getNlRowSolActivity +pyscipopt.recipes.nonlinear.Model.getNlRowSolFeasibility +pyscipopt.recipes.nonlinear.Model.getNlRows +pyscipopt.recipes.nonlinear.Model.getObjVal +pyscipopt.recipes.nonlinear.Model.getObjective +pyscipopt.recipes.nonlinear.Model.getObjectiveSense +pyscipopt.recipes.nonlinear.Model.getObjlimit +pyscipopt.recipes.nonlinear.Model.getObjoffset +pyscipopt.recipes.nonlinear.Model.getOpenNodes +pyscipopt.recipes.nonlinear.Model.getParam +pyscipopt.recipes.nonlinear.Model.getParams +pyscipopt.recipes.nonlinear.Model.getPlungeDepth +pyscipopt.recipes.nonlinear.Model.getPresolvingTime +pyscipopt.recipes.nonlinear.Model.getPrimalRay +pyscipopt.recipes.nonlinear.Model.getPrimalRayVal +pyscipopt.recipes.nonlinear.Model.getPrimalbound +pyscipopt.recipes.nonlinear.Model.getPrioChild +pyscipopt.recipes.nonlinear.Model.getPrioSibling +pyscipopt.recipes.nonlinear.Model.getProbName +pyscipopt.recipes.nonlinear.Model.getProbingDepth +pyscipopt.recipes.nonlinear.Model.getPseudoBranchCands +pyscipopt.recipes.nonlinear.Model.getReadingTime +pyscipopt.recipes.nonlinear.Model.getResultantAnd +pyscipopt.recipes.nonlinear.Model.getRhs +pyscipopt.recipes.nonlinear.Model.getRowActivity +pyscipopt.recipes.nonlinear.Model.getRowDualSol +pyscipopt.recipes.nonlinear.Model.getRowLPActivity +pyscipopt.recipes.nonlinear.Model.getRowLinear +pyscipopt.recipes.nonlinear.Model.getRowNumIntCols +pyscipopt.recipes.nonlinear.Model.getRowObjParallelism +pyscipopt.recipes.nonlinear.Model.getRowParallelism +pyscipopt.recipes.nonlinear.Model.getSiblings +pyscipopt.recipes.nonlinear.Model.getSlack +pyscipopt.recipes.nonlinear.Model.getSlackVarIndicator +pyscipopt.recipes.nonlinear.Model.getSolObjVal +pyscipopt.recipes.nonlinear.Model.getSolTime +pyscipopt.recipes.nonlinear.Model.getSolVal +pyscipopt.recipes.nonlinear.Model.getSols +pyscipopt.recipes.nonlinear.Model.getSolvingTime +pyscipopt.recipes.nonlinear.Model.getStage +pyscipopt.recipes.nonlinear.Model.getStageName +pyscipopt.recipes.nonlinear.Model.getStatus +pyscipopt.recipes.nonlinear.Model.getTechVersion +pyscipopt.recipes.nonlinear.Model.getTermsQuadratic +pyscipopt.recipes.nonlinear.Model.getTotalTime +pyscipopt.recipes.nonlinear.Model.getTransformedCons +pyscipopt.recipes.nonlinear.Model.getTransformedVar +pyscipopt.recipes.nonlinear.Model.getTreesizeEstimation +pyscipopt.recipes.nonlinear.Model.getVal +pyscipopt.recipes.nonlinear.Model.getValsLinear +pyscipopt.recipes.nonlinear.Model.getVarDict +pyscipopt.recipes.nonlinear.Model.getVarLbDive +pyscipopt.recipes.nonlinear.Model.getVarPseudocost +pyscipopt.recipes.nonlinear.Model.getVarPseudocostScore +pyscipopt.recipes.nonlinear.Model.getVarRedcost +pyscipopt.recipes.nonlinear.Model.getVarStrongbranch +pyscipopt.recipes.nonlinear.Model.getVarStrongbranchLast +pyscipopt.recipes.nonlinear.Model.getVarStrongbranchNode +pyscipopt.recipes.nonlinear.Model.getVarUbDive +pyscipopt.recipes.nonlinear.Model.getVars +pyscipopt.recipes.nonlinear.Model.getVarsAnd +pyscipopt.recipes.nonlinear.Model.getWeightsKnapsack +pyscipopt.recipes.nonlinear.Model.hasPrimalRay +pyscipopt.recipes.nonlinear.Model.hideOutput +pyscipopt.recipes.nonlinear.Model.inProbing +pyscipopt.recipes.nonlinear.Model.inRepropagation +pyscipopt.recipes.nonlinear.Model.includeBenders +pyscipopt.recipes.nonlinear.Model.includeBendersDefaultCuts +pyscipopt.recipes.nonlinear.Model.includeBenderscut +pyscipopt.recipes.nonlinear.Model.includeBranchrule +pyscipopt.recipes.nonlinear.Model.includeConshdlr +pyscipopt.recipes.nonlinear.Model.includeCutsel +pyscipopt.recipes.nonlinear.Model.includeDefaultPlugins +pyscipopt.recipes.nonlinear.Model.includeEventhdlr +pyscipopt.recipes.nonlinear.Model.includeHeur +pyscipopt.recipes.nonlinear.Model.includeIISfinder +pyscipopt.recipes.nonlinear.Model.includeNodesel +pyscipopt.recipes.nonlinear.Model.includePresol +pyscipopt.recipes.nonlinear.Model.includePricer +pyscipopt.recipes.nonlinear.Model.includeProp +pyscipopt.recipes.nonlinear.Model.includeReader +pyscipopt.recipes.nonlinear.Model.includeRelax +pyscipopt.recipes.nonlinear.Model.includeSepa +pyscipopt.recipes.nonlinear.Model.infinity +pyscipopt.recipes.nonlinear.Model.initBendersDefault +pyscipopt.recipes.nonlinear.Model.interruptSolve +pyscipopt.recipes.nonlinear.Model.isAndConsSorted +pyscipopt.recipes.nonlinear.Model.isCutEfficacious +pyscipopt.recipes.nonlinear.Model.isEQ +pyscipopt.recipes.nonlinear.Model.isExact +pyscipopt.recipes.nonlinear.Model.isFeasEQ +pyscipopt.recipes.nonlinear.Model.isFeasGE +pyscipopt.recipes.nonlinear.Model.isFeasGT +pyscipopt.recipes.nonlinear.Model.isFeasIntegral +pyscipopt.recipes.nonlinear.Model.isFeasLE +pyscipopt.recipes.nonlinear.Model.isFeasLT +pyscipopt.recipes.nonlinear.Model.isFeasNegative +pyscipopt.recipes.nonlinear.Model.isFeasPositive +pyscipopt.recipes.nonlinear.Model.isFeasZero +pyscipopt.recipes.nonlinear.Model.isGE +pyscipopt.recipes.nonlinear.Model.isGT +pyscipopt.recipes.nonlinear.Model.isHugeValue +pyscipopt.recipes.nonlinear.Model.isInfinity +pyscipopt.recipes.nonlinear.Model.isLE +pyscipopt.recipes.nonlinear.Model.isLPSolBasic +pyscipopt.recipes.nonlinear.Model.isLT +pyscipopt.recipes.nonlinear.Model.isNLPConstructed +pyscipopt.recipes.nonlinear.Model.isNegative +pyscipopt.recipes.nonlinear.Model.isObjChangedProbing +pyscipopt.recipes.nonlinear.Model.isPositive +pyscipopt.recipes.nonlinear.Model.isZero +pyscipopt.recipes.nonlinear.Model.lpiGetIterations +pyscipopt.recipes.nonlinear.Model.markDoNotAggrVar +pyscipopt.recipes.nonlinear.Model.markDoNotMultaggrVar +pyscipopt.recipes.nonlinear.Model.newProbingNode +pyscipopt.recipes.nonlinear.Model.optimize +pyscipopt.recipes.nonlinear.Model.optimizeNogil +pyscipopt.recipes.nonlinear.Model.presolve +pyscipopt.recipes.nonlinear.Model.printBestSol +pyscipopt.recipes.nonlinear.Model.printCons +pyscipopt.recipes.nonlinear.Model.printExternalCodeVersions +pyscipopt.recipes.nonlinear.Model.printNlRow +pyscipopt.recipes.nonlinear.Model.printProblem +pyscipopt.recipes.nonlinear.Model.printRow +pyscipopt.recipes.nonlinear.Model.printSol +pyscipopt.recipes.nonlinear.Model.printStatistics +pyscipopt.recipes.nonlinear.Model.printStatisticsJson +pyscipopt.recipes.nonlinear.Model.printVersion +pyscipopt.recipes.nonlinear.Model.propagateProbing +pyscipopt.recipes.nonlinear.Model.readParams +pyscipopt.recipes.nonlinear.Model.readProblem +pyscipopt.recipes.nonlinear.Model.readSol +pyscipopt.recipes.nonlinear.Model.readSolFile +pyscipopt.recipes.nonlinear.Model.redirectOutput +pyscipopt.recipes.nonlinear.Model.relax +pyscipopt.recipes.nonlinear.Model.releaseRow +pyscipopt.recipes.nonlinear.Model.repropagateNode +pyscipopt.recipes.nonlinear.Model.resetParam +pyscipopt.recipes.nonlinear.Model.resetParams +pyscipopt.recipes.nonlinear.Model.restartSolve +pyscipopt.recipes.nonlinear.Model.separateSol +pyscipopt.recipes.nonlinear.Model.setBendersSubproblemIsConvex +pyscipopt.recipes.nonlinear.Model.setBoolParam +pyscipopt.recipes.nonlinear.Model.setCharParam +pyscipopt.recipes.nonlinear.Model.setCheck +pyscipopt.recipes.nonlinear.Model.setEmphasis +pyscipopt.recipes.nonlinear.Model.setEnforced +pyscipopt.recipes.nonlinear.Model.setHeurTiming +pyscipopt.recipes.nonlinear.Model.setHeuristics +pyscipopt.recipes.nonlinear.Model.setInitial +pyscipopt.recipes.nonlinear.Model.setIntParam +pyscipopt.recipes.nonlinear.Model.setLogfile +pyscipopt.recipes.nonlinear.Model.setLongintParam +pyscipopt.recipes.nonlinear.Model.setMaximize +pyscipopt.recipes.nonlinear.Model.setMinimize +pyscipopt.recipes.nonlinear.Model.setModifiable +pyscipopt.recipes.nonlinear.Model.setObjIntegral +pyscipopt.recipes.nonlinear.Model.setObjective +pyscipopt.recipes.nonlinear.Model.setObjlimit +pyscipopt.recipes.nonlinear.Model.setParam +pyscipopt.recipes.nonlinear.Model.setParams +pyscipopt.recipes.nonlinear.Model.setParamsCountsols +pyscipopt.recipes.nonlinear.Model.setPresolve +pyscipopt.recipes.nonlinear.Model.setProbName +pyscipopt.recipes.nonlinear.Model.setRealParam +pyscipopt.recipes.nonlinear.Model.setRelaxSolVal +pyscipopt.recipes.nonlinear.Model.setRemovable +pyscipopt.recipes.nonlinear.Model.setSeparating +pyscipopt.recipes.nonlinear.Model.setSolVal +pyscipopt.recipes.nonlinear.Model.setStringParam +pyscipopt.recipes.nonlinear.Model.setupBendersSubproblem +pyscipopt.recipes.nonlinear.Model.solveBendersSubproblem +pyscipopt.recipes.nonlinear.Model.solveConcurrent +pyscipopt.recipes.nonlinear.Model.solveDiveLP +pyscipopt.recipes.nonlinear.Model.solveProbingLP +pyscipopt.recipes.nonlinear.Model.sortAndCons +pyscipopt.recipes.nonlinear.Model.startDive +pyscipopt.recipes.nonlinear.Model.startProbing +pyscipopt.recipes.nonlinear.Model.startStrongbranch +pyscipopt.recipes.nonlinear.Model.tightenVarLb +pyscipopt.recipes.nonlinear.Model.tightenVarLbGlobal +pyscipopt.recipes.nonlinear.Model.tightenVarUb +pyscipopt.recipes.nonlinear.Model.tightenVarUbGlobal +pyscipopt.recipes.nonlinear.Model.to_ptr +pyscipopt.recipes.nonlinear.Model.translateSubSol +pyscipopt.recipes.nonlinear.Model.trySol +pyscipopt.recipes.nonlinear.Model.updateBendersLowerbounds +pyscipopt.recipes.nonlinear.Model.updateNodeLowerbound +pyscipopt.recipes.nonlinear.Model.updateVarPseudocost +pyscipopt.recipes.nonlinear.Model.version +pyscipopt.recipes.nonlinear.Model.writeBestSol +pyscipopt.recipes.nonlinear.Model.writeBestTransSol +pyscipopt.recipes.nonlinear.Model.writeLP +pyscipopt.recipes.nonlinear.Model.writeMIP +pyscipopt.recipes.nonlinear.Model.writeName +pyscipopt.recipes.nonlinear.Model.writeParams +pyscipopt.recipes.nonlinear.Model.writeProblem +pyscipopt.recipes.nonlinear.Model.writeSol +pyscipopt.recipes.nonlinear.Model.writeStatistics +pyscipopt.recipes.nonlinear.Model.writeStatisticsJson +pyscipopt.recipes.nonlinear.Model.writeTransSol +pyscipopt.recipes.piecewise.Constraint +pyscipopt.recipes.piecewise.Constraint.__init__ +pyscipopt.recipes.piecewise.Constraint.getConshdlrName +pyscipopt.recipes.piecewise.Constraint.isActive +pyscipopt.recipes.piecewise.Constraint.isChecked +pyscipopt.recipes.piecewise.Constraint.isDynamic +pyscipopt.recipes.piecewise.Constraint.isEnforced +pyscipopt.recipes.piecewise.Constraint.isInitial +pyscipopt.recipes.piecewise.Constraint.isKnapsack +pyscipopt.recipes.piecewise.Constraint.isLinear +pyscipopt.recipes.piecewise.Constraint.isLinearType +pyscipopt.recipes.piecewise.Constraint.isLocal +pyscipopt.recipes.piecewise.Constraint.isModifiable +pyscipopt.recipes.piecewise.Constraint.isNonlinear +pyscipopt.recipes.piecewise.Constraint.isOriginal +pyscipopt.recipes.piecewise.Constraint.isPropagated +pyscipopt.recipes.piecewise.Constraint.isRemovable +pyscipopt.recipes.piecewise.Constraint.isSeparated +pyscipopt.recipes.piecewise.Constraint.isStickingAtNode +pyscipopt.recipes.piecewise.Model +pyscipopt.recipes.piecewise.Model._createConsGenNonlinear +pyscipopt.recipes.piecewise.Model._createConsLinear +pyscipopt.recipes.piecewise.Model._createConsNonlinear +pyscipopt.recipes.piecewise.Model._createConsQuadratic +pyscipopt.recipes.piecewise.Model._getStageNames +pyscipopt.recipes.piecewise.Model.activateBenders +pyscipopt.recipes.piecewise.Model.addBendersSubproblem +pyscipopt.recipes.piecewise.Model.addCoefKnapsack +pyscipopt.recipes.piecewise.Model.addCoefLinear +pyscipopt.recipes.piecewise.Model.addCons +pyscipopt.recipes.piecewise.Model.addConsAnd +pyscipopt.recipes.piecewise.Model.addConsCardinality +pyscipopt.recipes.piecewise.Model.addConsCoeff +pyscipopt.recipes.piecewise.Model.addConsDisjunction +pyscipopt.recipes.piecewise.Model.addConsElemDisjunction +pyscipopt.recipes.piecewise.Model.addConsIndicator +pyscipopt.recipes.piecewise.Model.addConsKnapsack +pyscipopt.recipes.piecewise.Model.addConsLocal +pyscipopt.recipes.piecewise.Model.addConsNode +pyscipopt.recipes.piecewise.Model.addConsOr +pyscipopt.recipes.piecewise.Model.addConsSOS1 +pyscipopt.recipes.piecewise.Model.addConsSOS2 +pyscipopt.recipes.piecewise.Model.addConsXor +pyscipopt.recipes.piecewise.Model.addConss +pyscipopt.recipes.piecewise.Model.addCut +pyscipopt.recipes.piecewise.Model.addExprNonlinear +pyscipopt.recipes.piecewise.Model.addMatrixCons +pyscipopt.recipes.piecewise.Model.addMatrixConsIndicator +pyscipopt.recipes.piecewise.Model.addMatrixVar +pyscipopt.recipes.piecewise.Model.addObjoffset +pyscipopt.recipes.piecewise.Model.addPoolCut +pyscipopt.recipes.piecewise.Model.addPyCons +pyscipopt.recipes.piecewise.Model.addRowDive +pyscipopt.recipes.piecewise.Model.addRowExact +pyscipopt.recipes.piecewise.Model.addSol +pyscipopt.recipes.piecewise.Model.addVar +pyscipopt.recipes.piecewise.Model.addVarLocks +pyscipopt.recipes.piecewise.Model.addVarLocksType +pyscipopt.recipes.piecewise.Model.addVarSOS1 +pyscipopt.recipes.piecewise.Model.addVarSOS2 +pyscipopt.recipes.piecewise.Model.addVarToRow +pyscipopt.recipes.piecewise.Model.allColsInLP +pyscipopt.recipes.piecewise.Model.allowNegSlackExact +pyscipopt.recipes.piecewise.Model.appendVarSOS1 +pyscipopt.recipes.piecewise.Model.appendVarSOS2 +pyscipopt.recipes.piecewise.Model.applyCutsProbing +pyscipopt.recipes.piecewise.Model.attachEventHandlerCallback +pyscipopt.recipes.piecewise.Model.backtrackProbing +pyscipopt.recipes.piecewise.Model.branchLPExact +pyscipopt.recipes.piecewise.Model.branchVar +pyscipopt.recipes.piecewise.Model.branchVarVal +pyscipopt.recipes.piecewise.Model.cacheRowExtensions +pyscipopt.recipes.piecewise.Model.calcChildEstimate +pyscipopt.recipes.piecewise.Model.calcNodeselPriority +pyscipopt.recipes.piecewise.Model.catchEvent +pyscipopt.recipes.piecewise.Model.catchRowEvent +pyscipopt.recipes.piecewise.Model.catchVarEvent +pyscipopt.recipes.piecewise.Model.checkBendersSubproblemOptimality +pyscipopt.recipes.piecewise.Model.checkQuadraticNonlinear +pyscipopt.recipes.piecewise.Model.checkSol +pyscipopt.recipes.piecewise.Model.chgCapacityKnapsack +pyscipopt.recipes.piecewise.Model.chgCoefLinear +pyscipopt.recipes.piecewise.Model.chgLhs +pyscipopt.recipes.piecewise.Model.chgReoptObjective +pyscipopt.recipes.piecewise.Model.chgRhs +pyscipopt.recipes.piecewise.Model.chgRowLhsDive +pyscipopt.recipes.piecewise.Model.chgRowRhsDive +pyscipopt.recipes.piecewise.Model.chgVarBranchPriority +pyscipopt.recipes.piecewise.Model.chgVarLb +pyscipopt.recipes.piecewise.Model.chgVarLbDive +pyscipopt.recipes.piecewise.Model.chgVarLbGlobal +pyscipopt.recipes.piecewise.Model.chgVarLbNode +pyscipopt.recipes.piecewise.Model.chgVarLbProbing +pyscipopt.recipes.piecewise.Model.chgVarObjDive +pyscipopt.recipes.piecewise.Model.chgVarObjProbing +pyscipopt.recipes.piecewise.Model.chgVarType +pyscipopt.recipes.piecewise.Model.chgVarUb +pyscipopt.recipes.piecewise.Model.chgVarUbDive +pyscipopt.recipes.piecewise.Model.chgVarUbGlobal +pyscipopt.recipes.piecewise.Model.chgVarUbNode +pyscipopt.recipes.piecewise.Model.chgVarUbProbing +pyscipopt.recipes.piecewise.Model.computeBestSolSubproblems +pyscipopt.recipes.piecewise.Model.constructLP +pyscipopt.recipes.piecewise.Model.copyLargeNeighborhoodSearch +pyscipopt.recipes.piecewise.Model.count +pyscipopt.recipes.piecewise.Model.createChild +pyscipopt.recipes.piecewise.Model.createCons +pyscipopt.recipes.piecewise.Model.createConsFromExpr +pyscipopt.recipes.piecewise.Model.createEmptyRowSepa +pyscipopt.recipes.piecewise.Model.createEmptyRowUnspec +pyscipopt.recipes.piecewise.Model.createOrigSol +pyscipopt.recipes.piecewise.Model.createPartialSol +pyscipopt.recipes.piecewise.Model.createProbBasic +pyscipopt.recipes.piecewise.Model.createSol +pyscipopt.recipes.piecewise.Model.cutoffNode +pyscipopt.recipes.piecewise.Model.deactivatePricer +pyscipopt.recipes.piecewise.Model.delCoefLinear +pyscipopt.recipes.piecewise.Model.delCons +pyscipopt.recipes.piecewise.Model.delConsLocal +pyscipopt.recipes.piecewise.Model.delVar +pyscipopt.recipes.piecewise.Model.disableDebugSol +pyscipopt.recipes.piecewise.Model.disablePropagation +pyscipopt.recipes.piecewise.Model.dropEvent +pyscipopt.recipes.piecewise.Model.dropRowEvent +pyscipopt.recipes.piecewise.Model.dropVarEvent +pyscipopt.recipes.piecewise.Model.enableDebugSol +pyscipopt.recipes.piecewise.Model.enableExactSolving +pyscipopt.recipes.piecewise.Model.enableReoptimization +pyscipopt.recipes.piecewise.Model.endDive +pyscipopt.recipes.piecewise.Model.endProbing +pyscipopt.recipes.piecewise.Model.endStrongbranch +pyscipopt.recipes.piecewise.Model.epsilon +pyscipopt.recipes.piecewise.Model.feasCeil +pyscipopt.recipes.piecewise.Model.feasFloor +pyscipopt.recipes.piecewise.Model.feasFrac +pyscipopt.recipes.piecewise.Model.feasRound +pyscipopt.recipes.piecewise.Model.feastol +pyscipopt.recipes.piecewise.Model.fixVar +pyscipopt.recipes.piecewise.Model.fixVarProbing +pyscipopt.recipes.piecewise.Model.flushRowExtensions +pyscipopt.recipes.piecewise.Model.frac +pyscipopt.recipes.piecewise.Model.freeBendersSubproblems +pyscipopt.recipes.piecewise.Model.freeProb +pyscipopt.recipes.piecewise.Model.freeReoptSolve +pyscipopt.recipes.piecewise.Model.freeSol +pyscipopt.recipes.piecewise.Model.freeTransform +pyscipopt.recipes.piecewise.Model.from_ptr +pyscipopt.recipes.piecewise.Model.generateIIS +pyscipopt.recipes.piecewise.Model.getActivity +pyscipopt.recipes.piecewise.Model.getBendersAuxiliaryVar +pyscipopt.recipes.piecewise.Model.getBendersSubproblem +pyscipopt.recipes.piecewise.Model.getBendersVar +pyscipopt.recipes.piecewise.Model.getBestChild +pyscipopt.recipes.piecewise.Model.getBestLeaf +pyscipopt.recipes.piecewise.Model.getBestNode +pyscipopt.recipes.piecewise.Model.getBestSibling +pyscipopt.recipes.piecewise.Model.getBestSol +pyscipopt.recipes.piecewise.Model.getBestboundNode +pyscipopt.recipes.piecewise.Model.getBipartiteGraphRepresentation +pyscipopt.recipes.piecewise.Model.getBranchScoreMultiple +pyscipopt.recipes.piecewise.Model.getCapacityKnapsack +pyscipopt.recipes.piecewise.Model.getChildren +pyscipopt.recipes.piecewise.Model.getColRedCost +pyscipopt.recipes.piecewise.Model.getCondition +pyscipopt.recipes.piecewise.Model.getConsNVars +pyscipopt.recipes.piecewise.Model.getConsVals +pyscipopt.recipes.piecewise.Model.getConsVars +pyscipopt.recipes.piecewise.Model.getConss +pyscipopt.recipes.piecewise.Model.getCurrentNode +pyscipopt.recipes.piecewise.Model.getCutEfficacy +pyscipopt.recipes.piecewise.Model.getCutLPSolCutoffDistance +pyscipopt.recipes.piecewise.Model.getCutoffbound +pyscipopt.recipes.piecewise.Model.getDepth +pyscipopt.recipes.piecewise.Model.getDualMultiplier +pyscipopt.recipes.piecewise.Model.getDualSolVal +pyscipopt.recipes.piecewise.Model.getDualbound +pyscipopt.recipes.piecewise.Model.getDualboundRoot +pyscipopt.recipes.piecewise.Model.getDualfarkasKnapsack +pyscipopt.recipes.piecewise.Model.getDualfarkasLinear +pyscipopt.recipes.piecewise.Model.getDualsolKnapsack +pyscipopt.recipes.piecewise.Model.getDualsolLinear +pyscipopt.recipes.piecewise.Model.getGap +pyscipopt.recipes.piecewise.Model.getHeurTiming +pyscipopt.recipes.piecewise.Model.getIIS +pyscipopt.recipes.piecewise.Model.getLPBInvARow +pyscipopt.recipes.piecewise.Model.getLPBInvRow +pyscipopt.recipes.piecewise.Model.getLPBasisInd +pyscipopt.recipes.piecewise.Model.getLPBranchCands +pyscipopt.recipes.piecewise.Model.getLPColsData +pyscipopt.recipes.piecewise.Model.getLPObjVal +pyscipopt.recipes.piecewise.Model.getLPRowsData +pyscipopt.recipes.piecewise.Model.getLPSolstat +pyscipopt.recipes.piecewise.Model.getLeaves +pyscipopt.recipes.piecewise.Model.getLhs +pyscipopt.recipes.piecewise.Model.getLinearConsIndicator +pyscipopt.recipes.piecewise.Model.getLocalEstimate +pyscipopt.recipes.piecewise.Model.getLowerbound +pyscipopt.recipes.piecewise.Model.getMajorVersion +pyscipopt.recipes.piecewise.Model.getMaxDepth +pyscipopt.recipes.piecewise.Model.getMinorVersion +pyscipopt.recipes.piecewise.Model.getNBestSolsFound +pyscipopt.recipes.piecewise.Model.getNBinVars +pyscipopt.recipes.piecewise.Model.getNChildren +pyscipopt.recipes.piecewise.Model.getNConss +pyscipopt.recipes.piecewise.Model.getNContVars +pyscipopt.recipes.piecewise.Model.getNCountedSols +pyscipopt.recipes.piecewise.Model.getNCuts +pyscipopt.recipes.piecewise.Model.getNCutsApplied +pyscipopt.recipes.piecewise.Model.getNFeasibleLeaves +pyscipopt.recipes.piecewise.Model.getNImplVars +pyscipopt.recipes.piecewise.Model.getNInfeasibleLeaves +pyscipopt.recipes.piecewise.Model.getNIntVars +pyscipopt.recipes.piecewise.Model.getNLPBranchCands +pyscipopt.recipes.piecewise.Model.getNLPCols +pyscipopt.recipes.piecewise.Model.getNLPIterations +pyscipopt.recipes.piecewise.Model.getNLPRows +pyscipopt.recipes.piecewise.Model.getNLPs +pyscipopt.recipes.piecewise.Model.getNLeaves +pyscipopt.recipes.piecewise.Model.getNLimSolsFound +pyscipopt.recipes.piecewise.Model.getNNlRows +pyscipopt.recipes.piecewise.Model.getNNodeLPIterations +pyscipopt.recipes.piecewise.Model.getNNodes +pyscipopt.recipes.piecewise.Model.getNReaders +pyscipopt.recipes.piecewise.Model.getNSepaRounds +pyscipopt.recipes.piecewise.Model.getNSiblings +pyscipopt.recipes.piecewise.Model.getNSols +pyscipopt.recipes.piecewise.Model.getNSolsFound +pyscipopt.recipes.piecewise.Model.getNStrongbranchLPIterations +pyscipopt.recipes.piecewise.Model.getNTotalNodes +pyscipopt.recipes.piecewise.Model.getNVars +pyscipopt.recipes.piecewise.Model.getNVarsAnd +pyscipopt.recipes.piecewise.Model.getNlRowActivityBounds +pyscipopt.recipes.piecewise.Model.getNlRowSolActivity +pyscipopt.recipes.piecewise.Model.getNlRowSolFeasibility +pyscipopt.recipes.piecewise.Model.getNlRows +pyscipopt.recipes.piecewise.Model.getObjVal +pyscipopt.recipes.piecewise.Model.getObjective +pyscipopt.recipes.piecewise.Model.getObjectiveSense +pyscipopt.recipes.piecewise.Model.getObjlimit +pyscipopt.recipes.piecewise.Model.getObjoffset +pyscipopt.recipes.piecewise.Model.getOpenNodes +pyscipopt.recipes.piecewise.Model.getParam +pyscipopt.recipes.piecewise.Model.getParams +pyscipopt.recipes.piecewise.Model.getPlungeDepth +pyscipopt.recipes.piecewise.Model.getPresolvingTime +pyscipopt.recipes.piecewise.Model.getPrimalRay +pyscipopt.recipes.piecewise.Model.getPrimalRayVal +pyscipopt.recipes.piecewise.Model.getPrimalbound +pyscipopt.recipes.piecewise.Model.getPrioChild +pyscipopt.recipes.piecewise.Model.getPrioSibling +pyscipopt.recipes.piecewise.Model.getProbName +pyscipopt.recipes.piecewise.Model.getProbingDepth +pyscipopt.recipes.piecewise.Model.getPseudoBranchCands +pyscipopt.recipes.piecewise.Model.getReadingTime +pyscipopt.recipes.piecewise.Model.getResultantAnd +pyscipopt.recipes.piecewise.Model.getRhs +pyscipopt.recipes.piecewise.Model.getRowActivity +pyscipopt.recipes.piecewise.Model.getRowDualSol +pyscipopt.recipes.piecewise.Model.getRowLPActivity +pyscipopt.recipes.piecewise.Model.getRowLinear +pyscipopt.recipes.piecewise.Model.getRowNumIntCols +pyscipopt.recipes.piecewise.Model.getRowObjParallelism +pyscipopt.recipes.piecewise.Model.getRowParallelism +pyscipopt.recipes.piecewise.Model.getSiblings +pyscipopt.recipes.piecewise.Model.getSlack +pyscipopt.recipes.piecewise.Model.getSlackVarIndicator +pyscipopt.recipes.piecewise.Model.getSolObjVal +pyscipopt.recipes.piecewise.Model.getSolTime +pyscipopt.recipes.piecewise.Model.getSolVal +pyscipopt.recipes.piecewise.Model.getSols +pyscipopt.recipes.piecewise.Model.getSolvingTime +pyscipopt.recipes.piecewise.Model.getStage +pyscipopt.recipes.piecewise.Model.getStageName +pyscipopt.recipes.piecewise.Model.getStatus +pyscipopt.recipes.piecewise.Model.getTechVersion +pyscipopt.recipes.piecewise.Model.getTermsQuadratic +pyscipopt.recipes.piecewise.Model.getTotalTime +pyscipopt.recipes.piecewise.Model.getTransformedCons +pyscipopt.recipes.piecewise.Model.getTransformedVar +pyscipopt.recipes.piecewise.Model.getTreesizeEstimation +pyscipopt.recipes.piecewise.Model.getVal +pyscipopt.recipes.piecewise.Model.getValsLinear +pyscipopt.recipes.piecewise.Model.getVarDict +pyscipopt.recipes.piecewise.Model.getVarLbDive +pyscipopt.recipes.piecewise.Model.getVarPseudocost +pyscipopt.recipes.piecewise.Model.getVarPseudocostScore +pyscipopt.recipes.piecewise.Model.getVarRedcost +pyscipopt.recipes.piecewise.Model.getVarStrongbranch +pyscipopt.recipes.piecewise.Model.getVarStrongbranchLast +pyscipopt.recipes.piecewise.Model.getVarStrongbranchNode +pyscipopt.recipes.piecewise.Model.getVarUbDive +pyscipopt.recipes.piecewise.Model.getVars +pyscipopt.recipes.piecewise.Model.getVarsAnd +pyscipopt.recipes.piecewise.Model.getWeightsKnapsack +pyscipopt.recipes.piecewise.Model.hasPrimalRay +pyscipopt.recipes.piecewise.Model.hideOutput +pyscipopt.recipes.piecewise.Model.inProbing +pyscipopt.recipes.piecewise.Model.inRepropagation +pyscipopt.recipes.piecewise.Model.includeBenders +pyscipopt.recipes.piecewise.Model.includeBendersDefaultCuts +pyscipopt.recipes.piecewise.Model.includeBenderscut +pyscipopt.recipes.piecewise.Model.includeBranchrule +pyscipopt.recipes.piecewise.Model.includeConshdlr +pyscipopt.recipes.piecewise.Model.includeCutsel +pyscipopt.recipes.piecewise.Model.includeDefaultPlugins +pyscipopt.recipes.piecewise.Model.includeEventhdlr +pyscipopt.recipes.piecewise.Model.includeHeur +pyscipopt.recipes.piecewise.Model.includeIISfinder +pyscipopt.recipes.piecewise.Model.includeNodesel +pyscipopt.recipes.piecewise.Model.includePresol +pyscipopt.recipes.piecewise.Model.includePricer +pyscipopt.recipes.piecewise.Model.includeProp +pyscipopt.recipes.piecewise.Model.includeReader +pyscipopt.recipes.piecewise.Model.includeRelax +pyscipopt.recipes.piecewise.Model.includeSepa +pyscipopt.recipes.piecewise.Model.infinity +pyscipopt.recipes.piecewise.Model.initBendersDefault +pyscipopt.recipes.piecewise.Model.interruptSolve +pyscipopt.recipes.piecewise.Model.isAndConsSorted +pyscipopt.recipes.piecewise.Model.isCutEfficacious +pyscipopt.recipes.piecewise.Model.isEQ +pyscipopt.recipes.piecewise.Model.isExact +pyscipopt.recipes.piecewise.Model.isFeasEQ +pyscipopt.recipes.piecewise.Model.isFeasGE +pyscipopt.recipes.piecewise.Model.isFeasGT +pyscipopt.recipes.piecewise.Model.isFeasIntegral +pyscipopt.recipes.piecewise.Model.isFeasLE +pyscipopt.recipes.piecewise.Model.isFeasLT +pyscipopt.recipes.piecewise.Model.isFeasNegative +pyscipopt.recipes.piecewise.Model.isFeasPositive +pyscipopt.recipes.piecewise.Model.isFeasZero +pyscipopt.recipes.piecewise.Model.isGE +pyscipopt.recipes.piecewise.Model.isGT +pyscipopt.recipes.piecewise.Model.isHugeValue +pyscipopt.recipes.piecewise.Model.isInfinity +pyscipopt.recipes.piecewise.Model.isLE +pyscipopt.recipes.piecewise.Model.isLPSolBasic +pyscipopt.recipes.piecewise.Model.isLT +pyscipopt.recipes.piecewise.Model.isNLPConstructed +pyscipopt.recipes.piecewise.Model.isNegative +pyscipopt.recipes.piecewise.Model.isObjChangedProbing +pyscipopt.recipes.piecewise.Model.isPositive +pyscipopt.recipes.piecewise.Model.isZero +pyscipopt.recipes.piecewise.Model.lpiGetIterations +pyscipopt.recipes.piecewise.Model.markDoNotAggrVar +pyscipopt.recipes.piecewise.Model.markDoNotMultaggrVar +pyscipopt.recipes.piecewise.Model.newProbingNode +pyscipopt.recipes.piecewise.Model.optimize +pyscipopt.recipes.piecewise.Model.optimizeNogil +pyscipopt.recipes.piecewise.Model.presolve +pyscipopt.recipes.piecewise.Model.printBestSol +pyscipopt.recipes.piecewise.Model.printCons +pyscipopt.recipes.piecewise.Model.printExternalCodeVersions +pyscipopt.recipes.piecewise.Model.printNlRow +pyscipopt.recipes.piecewise.Model.printProblem +pyscipopt.recipes.piecewise.Model.printRow +pyscipopt.recipes.piecewise.Model.printSol +pyscipopt.recipes.piecewise.Model.printStatistics +pyscipopt.recipes.piecewise.Model.printStatisticsJson +pyscipopt.recipes.piecewise.Model.printVersion +pyscipopt.recipes.piecewise.Model.propagateProbing +pyscipopt.recipes.piecewise.Model.readParams +pyscipopt.recipes.piecewise.Model.readProblem +pyscipopt.recipes.piecewise.Model.readSol +pyscipopt.recipes.piecewise.Model.readSolFile +pyscipopt.recipes.piecewise.Model.redirectOutput +pyscipopt.recipes.piecewise.Model.relax +pyscipopt.recipes.piecewise.Model.releaseRow +pyscipopt.recipes.piecewise.Model.repropagateNode +pyscipopt.recipes.piecewise.Model.resetParam +pyscipopt.recipes.piecewise.Model.resetParams +pyscipopt.recipes.piecewise.Model.restartSolve +pyscipopt.recipes.piecewise.Model.separateSol +pyscipopt.recipes.piecewise.Model.setBendersSubproblemIsConvex +pyscipopt.recipes.piecewise.Model.setBoolParam +pyscipopt.recipes.piecewise.Model.setCharParam +pyscipopt.recipes.piecewise.Model.setCheck +pyscipopt.recipes.piecewise.Model.setEmphasis +pyscipopt.recipes.piecewise.Model.setEnforced +pyscipopt.recipes.piecewise.Model.setHeurTiming +pyscipopt.recipes.piecewise.Model.setHeuristics +pyscipopt.recipes.piecewise.Model.setInitial +pyscipopt.recipes.piecewise.Model.setIntParam +pyscipopt.recipes.piecewise.Model.setLogfile +pyscipopt.recipes.piecewise.Model.setLongintParam +pyscipopt.recipes.piecewise.Model.setMaximize +pyscipopt.recipes.piecewise.Model.setMinimize +pyscipopt.recipes.piecewise.Model.setModifiable +pyscipopt.recipes.piecewise.Model.setObjIntegral +pyscipopt.recipes.piecewise.Model.setObjective +pyscipopt.recipes.piecewise.Model.setObjlimit +pyscipopt.recipes.piecewise.Model.setParam +pyscipopt.recipes.piecewise.Model.setParams +pyscipopt.recipes.piecewise.Model.setParamsCountsols +pyscipopt.recipes.piecewise.Model.setPresolve +pyscipopt.recipes.piecewise.Model.setProbName +pyscipopt.recipes.piecewise.Model.setRealParam +pyscipopt.recipes.piecewise.Model.setRelaxSolVal +pyscipopt.recipes.piecewise.Model.setRemovable +pyscipopt.recipes.piecewise.Model.setSeparating +pyscipopt.recipes.piecewise.Model.setSolVal +pyscipopt.recipes.piecewise.Model.setStringParam +pyscipopt.recipes.piecewise.Model.setupBendersSubproblem +pyscipopt.recipes.piecewise.Model.solveBendersSubproblem +pyscipopt.recipes.piecewise.Model.solveConcurrent +pyscipopt.recipes.piecewise.Model.solveDiveLP +pyscipopt.recipes.piecewise.Model.solveProbingLP +pyscipopt.recipes.piecewise.Model.sortAndCons +pyscipopt.recipes.piecewise.Model.startDive +pyscipopt.recipes.piecewise.Model.startProbing +pyscipopt.recipes.piecewise.Model.startStrongbranch +pyscipopt.recipes.piecewise.Model.tightenVarLb +pyscipopt.recipes.piecewise.Model.tightenVarLbGlobal +pyscipopt.recipes.piecewise.Model.tightenVarUb +pyscipopt.recipes.piecewise.Model.tightenVarUbGlobal +pyscipopt.recipes.piecewise.Model.to_ptr +pyscipopt.recipes.piecewise.Model.translateSubSol +pyscipopt.recipes.piecewise.Model.trySol +pyscipopt.recipes.piecewise.Model.updateBendersLowerbounds +pyscipopt.recipes.piecewise.Model.updateNodeLowerbound +pyscipopt.recipes.piecewise.Model.updateVarPseudocost +pyscipopt.recipes.piecewise.Model.version +pyscipopt.recipes.piecewise.Model.writeBestSol +pyscipopt.recipes.piecewise.Model.writeBestTransSol +pyscipopt.recipes.piecewise.Model.writeLP +pyscipopt.recipes.piecewise.Model.writeMIP +pyscipopt.recipes.piecewise.Model.writeName +pyscipopt.recipes.piecewise.Model.writeParams +pyscipopt.recipes.piecewise.Model.writeProblem +pyscipopt.recipes.piecewise.Model.writeSol +pyscipopt.recipes.piecewise.Model.writeStatistics +pyscipopt.recipes.piecewise.Model.writeStatisticsJson +pyscipopt.recipes.piecewise.Model.writeTransSol +pyscipopt.recipes.piecewise.Variable +pyscipopt.recipes.piecewise.Variable.getAvgSol +pyscipopt.recipes.piecewise.Variable.getCol +pyscipopt.recipes.piecewise.Variable.getImplType +pyscipopt.recipes.piecewise.Variable.getIndex +pyscipopt.recipes.piecewise.Variable.getLPSol +pyscipopt.recipes.piecewise.Variable.getLbGlobal +pyscipopt.recipes.piecewise.Variable.getLbLocal +pyscipopt.recipes.piecewise.Variable.getLbOriginal +pyscipopt.recipes.piecewise.Variable.getNBranchings +pyscipopt.recipes.piecewise.Variable.getNBranchingsCurrentRun +pyscipopt.recipes.piecewise.Variable.getNLocksDown +pyscipopt.recipes.piecewise.Variable.getNLocksDownType +pyscipopt.recipes.piecewise.Variable.getNLocksUp +pyscipopt.recipes.piecewise.Variable.getNLocksUpType +pyscipopt.recipes.piecewise.Variable.getObj +pyscipopt.recipes.piecewise.Variable.getStatus +pyscipopt.recipes.piecewise.Variable.getUbGlobal +pyscipopt.recipes.piecewise.Variable.getUbLocal +pyscipopt.recipes.piecewise.Variable.getUbOriginal +pyscipopt.recipes.piecewise.Variable.isActive +pyscipopt.recipes.piecewise.Variable.isBinary +pyscipopt.recipes.piecewise.Variable.isDeletable +pyscipopt.recipes.piecewise.Variable.isImpliedIntegral +pyscipopt.recipes.piecewise.Variable.isInLP +pyscipopt.recipes.piecewise.Variable.isIntegral +pyscipopt.recipes.piecewise.Variable.isNonImpliedIntegral +pyscipopt.recipes.piecewise.Variable.isOriginal +pyscipopt.recipes.piecewise.Variable.isRelaxationOnly +pyscipopt.recipes.piecewise.Variable.markRelaxationOnly +pyscipopt.recipes.piecewise.Variable.ptr +pyscipopt.recipes.piecewise.Variable.varMayRound +pyscipopt.recipes.piecewise.Variable.vtype +pyscipopt.recipes.primal_dual_evolution.Eventhdlr +pyscipopt.recipes.primal_dual_evolution.Eventhdlr.__init__ +pyscipopt.recipes.primal_dual_evolution.Eventhdlr.eventcopy +pyscipopt.recipes.primal_dual_evolution.Eventhdlr.eventdelete +pyscipopt.recipes.primal_dual_evolution.Eventhdlr.eventexec +pyscipopt.recipes.primal_dual_evolution.Eventhdlr.eventexit +pyscipopt.recipes.primal_dual_evolution.Eventhdlr.eventexitsol +pyscipopt.recipes.primal_dual_evolution.Eventhdlr.eventfree +pyscipopt.recipes.primal_dual_evolution.Eventhdlr.eventinit +pyscipopt.recipes.primal_dual_evolution.Eventhdlr.eventinitsol +pyscipopt.recipes.primal_dual_evolution.GapEventhdlr@14 +pyscipopt.recipes.primal_dual_evolution.Model +pyscipopt.recipes.primal_dual_evolution.Model._createConsGenNonlinear +pyscipopt.recipes.primal_dual_evolution.Model._createConsLinear +pyscipopt.recipes.primal_dual_evolution.Model._createConsNonlinear +pyscipopt.recipes.primal_dual_evolution.Model._createConsQuadratic +pyscipopt.recipes.primal_dual_evolution.Model._getStageNames +pyscipopt.recipes.primal_dual_evolution.Model.activateBenders +pyscipopt.recipes.primal_dual_evolution.Model.addBendersSubproblem +pyscipopt.recipes.primal_dual_evolution.Model.addCoefKnapsack +pyscipopt.recipes.primal_dual_evolution.Model.addCoefLinear +pyscipopt.recipes.primal_dual_evolution.Model.addCons +pyscipopt.recipes.primal_dual_evolution.Model.addConsAnd +pyscipopt.recipes.primal_dual_evolution.Model.addConsCardinality +pyscipopt.recipes.primal_dual_evolution.Model.addConsCoeff +pyscipopt.recipes.primal_dual_evolution.Model.addConsDisjunction +pyscipopt.recipes.primal_dual_evolution.Model.addConsElemDisjunction +pyscipopt.recipes.primal_dual_evolution.Model.addConsIndicator +pyscipopt.recipes.primal_dual_evolution.Model.addConsKnapsack +pyscipopt.recipes.primal_dual_evolution.Model.addConsLocal +pyscipopt.recipes.primal_dual_evolution.Model.addConsNode +pyscipopt.recipes.primal_dual_evolution.Model.addConsOr +pyscipopt.recipes.primal_dual_evolution.Model.addConsSOS1 +pyscipopt.recipes.primal_dual_evolution.Model.addConsSOS2 +pyscipopt.recipes.primal_dual_evolution.Model.addConsXor +pyscipopt.recipes.primal_dual_evolution.Model.addConss +pyscipopt.recipes.primal_dual_evolution.Model.addCut +pyscipopt.recipes.primal_dual_evolution.Model.addExprNonlinear +pyscipopt.recipes.primal_dual_evolution.Model.addMatrixCons +pyscipopt.recipes.primal_dual_evolution.Model.addMatrixConsIndicator +pyscipopt.recipes.primal_dual_evolution.Model.addMatrixVar +pyscipopt.recipes.primal_dual_evolution.Model.addObjoffset +pyscipopt.recipes.primal_dual_evolution.Model.addPoolCut +pyscipopt.recipes.primal_dual_evolution.Model.addPyCons +pyscipopt.recipes.primal_dual_evolution.Model.addRowDive +pyscipopt.recipes.primal_dual_evolution.Model.addRowExact +pyscipopt.recipes.primal_dual_evolution.Model.addSol +pyscipopt.recipes.primal_dual_evolution.Model.addVar +pyscipopt.recipes.primal_dual_evolution.Model.addVarLocks +pyscipopt.recipes.primal_dual_evolution.Model.addVarLocksType +pyscipopt.recipes.primal_dual_evolution.Model.addVarSOS1 +pyscipopt.recipes.primal_dual_evolution.Model.addVarSOS2 +pyscipopt.recipes.primal_dual_evolution.Model.addVarToRow +pyscipopt.recipes.primal_dual_evolution.Model.allColsInLP +pyscipopt.recipes.primal_dual_evolution.Model.allowNegSlackExact +pyscipopt.recipes.primal_dual_evolution.Model.appendVarSOS1 +pyscipopt.recipes.primal_dual_evolution.Model.appendVarSOS2 +pyscipopt.recipes.primal_dual_evolution.Model.applyCutsProbing +pyscipopt.recipes.primal_dual_evolution.Model.attachEventHandlerCallback +pyscipopt.recipes.primal_dual_evolution.Model.backtrackProbing +pyscipopt.recipes.primal_dual_evolution.Model.branchLPExact +pyscipopt.recipes.primal_dual_evolution.Model.branchVar +pyscipopt.recipes.primal_dual_evolution.Model.branchVarVal +pyscipopt.recipes.primal_dual_evolution.Model.cacheRowExtensions +pyscipopt.recipes.primal_dual_evolution.Model.calcChildEstimate +pyscipopt.recipes.primal_dual_evolution.Model.calcNodeselPriority +pyscipopt.recipes.primal_dual_evolution.Model.catchEvent +pyscipopt.recipes.primal_dual_evolution.Model.catchRowEvent +pyscipopt.recipes.primal_dual_evolution.Model.catchVarEvent +pyscipopt.recipes.primal_dual_evolution.Model.checkBendersSubproblemOptimality +pyscipopt.recipes.primal_dual_evolution.Model.checkQuadraticNonlinear +pyscipopt.recipes.primal_dual_evolution.Model.checkSol +pyscipopt.recipes.primal_dual_evolution.Model.chgCapacityKnapsack +pyscipopt.recipes.primal_dual_evolution.Model.chgCoefLinear +pyscipopt.recipes.primal_dual_evolution.Model.chgLhs +pyscipopt.recipes.primal_dual_evolution.Model.chgReoptObjective +pyscipopt.recipes.primal_dual_evolution.Model.chgRhs +pyscipopt.recipes.primal_dual_evolution.Model.chgRowLhsDive +pyscipopt.recipes.primal_dual_evolution.Model.chgRowRhsDive +pyscipopt.recipes.primal_dual_evolution.Model.chgVarBranchPriority +pyscipopt.recipes.primal_dual_evolution.Model.chgVarLb +pyscipopt.recipes.primal_dual_evolution.Model.chgVarLbDive +pyscipopt.recipes.primal_dual_evolution.Model.chgVarLbGlobal +pyscipopt.recipes.primal_dual_evolution.Model.chgVarLbNode +pyscipopt.recipes.primal_dual_evolution.Model.chgVarLbProbing +pyscipopt.recipes.primal_dual_evolution.Model.chgVarObjDive +pyscipopt.recipes.primal_dual_evolution.Model.chgVarObjProbing +pyscipopt.recipes.primal_dual_evolution.Model.chgVarType +pyscipopt.recipes.primal_dual_evolution.Model.chgVarUb +pyscipopt.recipes.primal_dual_evolution.Model.chgVarUbDive +pyscipopt.recipes.primal_dual_evolution.Model.chgVarUbGlobal +pyscipopt.recipes.primal_dual_evolution.Model.chgVarUbNode +pyscipopt.recipes.primal_dual_evolution.Model.chgVarUbProbing +pyscipopt.recipes.primal_dual_evolution.Model.computeBestSolSubproblems +pyscipopt.recipes.primal_dual_evolution.Model.constructLP +pyscipopt.recipes.primal_dual_evolution.Model.copyLargeNeighborhoodSearch +pyscipopt.recipes.primal_dual_evolution.Model.count +pyscipopt.recipes.primal_dual_evolution.Model.createChild +pyscipopt.recipes.primal_dual_evolution.Model.createCons +pyscipopt.recipes.primal_dual_evolution.Model.createConsFromExpr +pyscipopt.recipes.primal_dual_evolution.Model.createEmptyRowSepa +pyscipopt.recipes.primal_dual_evolution.Model.createEmptyRowUnspec +pyscipopt.recipes.primal_dual_evolution.Model.createOrigSol +pyscipopt.recipes.primal_dual_evolution.Model.createPartialSol +pyscipopt.recipes.primal_dual_evolution.Model.createProbBasic +pyscipopt.recipes.primal_dual_evolution.Model.createSol +pyscipopt.recipes.primal_dual_evolution.Model.cutoffNode +pyscipopt.recipes.primal_dual_evolution.Model.deactivatePricer +pyscipopt.recipes.primal_dual_evolution.Model.delCoefLinear +pyscipopt.recipes.primal_dual_evolution.Model.delCons +pyscipopt.recipes.primal_dual_evolution.Model.delConsLocal +pyscipopt.recipes.primal_dual_evolution.Model.delVar +pyscipopt.recipes.primal_dual_evolution.Model.disableDebugSol +pyscipopt.recipes.primal_dual_evolution.Model.disablePropagation +pyscipopt.recipes.primal_dual_evolution.Model.dropEvent +pyscipopt.recipes.primal_dual_evolution.Model.dropRowEvent +pyscipopt.recipes.primal_dual_evolution.Model.dropVarEvent +pyscipopt.recipes.primal_dual_evolution.Model.enableDebugSol +pyscipopt.recipes.primal_dual_evolution.Model.enableExactSolving +pyscipopt.recipes.primal_dual_evolution.Model.enableReoptimization +pyscipopt.recipes.primal_dual_evolution.Model.endDive +pyscipopt.recipes.primal_dual_evolution.Model.endProbing +pyscipopt.recipes.primal_dual_evolution.Model.endStrongbranch +pyscipopt.recipes.primal_dual_evolution.Model.epsilon +pyscipopt.recipes.primal_dual_evolution.Model.feasCeil +pyscipopt.recipes.primal_dual_evolution.Model.feasFloor +pyscipopt.recipes.primal_dual_evolution.Model.feasFrac +pyscipopt.recipes.primal_dual_evolution.Model.feasRound +pyscipopt.recipes.primal_dual_evolution.Model.feastol +pyscipopt.recipes.primal_dual_evolution.Model.fixVar +pyscipopt.recipes.primal_dual_evolution.Model.fixVarProbing +pyscipopt.recipes.primal_dual_evolution.Model.flushRowExtensions +pyscipopt.recipes.primal_dual_evolution.Model.frac +pyscipopt.recipes.primal_dual_evolution.Model.freeBendersSubproblems +pyscipopt.recipes.primal_dual_evolution.Model.freeProb +pyscipopt.recipes.primal_dual_evolution.Model.freeReoptSolve +pyscipopt.recipes.primal_dual_evolution.Model.freeSol +pyscipopt.recipes.primal_dual_evolution.Model.freeTransform +pyscipopt.recipes.primal_dual_evolution.Model.from_ptr +pyscipopt.recipes.primal_dual_evolution.Model.generateIIS +pyscipopt.recipes.primal_dual_evolution.Model.getActivity +pyscipopt.recipes.primal_dual_evolution.Model.getBendersAuxiliaryVar +pyscipopt.recipes.primal_dual_evolution.Model.getBendersSubproblem +pyscipopt.recipes.primal_dual_evolution.Model.getBendersVar +pyscipopt.recipes.primal_dual_evolution.Model.getBestChild +pyscipopt.recipes.primal_dual_evolution.Model.getBestLeaf +pyscipopt.recipes.primal_dual_evolution.Model.getBestNode +pyscipopt.recipes.primal_dual_evolution.Model.getBestSibling +pyscipopt.recipes.primal_dual_evolution.Model.getBestSol +pyscipopt.recipes.primal_dual_evolution.Model.getBestboundNode +pyscipopt.recipes.primal_dual_evolution.Model.getBipartiteGraphRepresentation +pyscipopt.recipes.primal_dual_evolution.Model.getBranchScoreMultiple +pyscipopt.recipes.primal_dual_evolution.Model.getCapacityKnapsack +pyscipopt.recipes.primal_dual_evolution.Model.getChildren +pyscipopt.recipes.primal_dual_evolution.Model.getColRedCost +pyscipopt.recipes.primal_dual_evolution.Model.getCondition +pyscipopt.recipes.primal_dual_evolution.Model.getConsNVars +pyscipopt.recipes.primal_dual_evolution.Model.getConsVals +pyscipopt.recipes.primal_dual_evolution.Model.getConsVars +pyscipopt.recipes.primal_dual_evolution.Model.getConss +pyscipopt.recipes.primal_dual_evolution.Model.getCurrentNode +pyscipopt.recipes.primal_dual_evolution.Model.getCutEfficacy +pyscipopt.recipes.primal_dual_evolution.Model.getCutLPSolCutoffDistance +pyscipopt.recipes.primal_dual_evolution.Model.getCutoffbound +pyscipopt.recipes.primal_dual_evolution.Model.getDepth +pyscipopt.recipes.primal_dual_evolution.Model.getDualMultiplier +pyscipopt.recipes.primal_dual_evolution.Model.getDualSolVal +pyscipopt.recipes.primal_dual_evolution.Model.getDualbound +pyscipopt.recipes.primal_dual_evolution.Model.getDualboundRoot +pyscipopt.recipes.primal_dual_evolution.Model.getDualfarkasKnapsack +pyscipopt.recipes.primal_dual_evolution.Model.getDualfarkasLinear +pyscipopt.recipes.primal_dual_evolution.Model.getDualsolKnapsack +pyscipopt.recipes.primal_dual_evolution.Model.getDualsolLinear +pyscipopt.recipes.primal_dual_evolution.Model.getGap +pyscipopt.recipes.primal_dual_evolution.Model.getHeurTiming +pyscipopt.recipes.primal_dual_evolution.Model.getIIS +pyscipopt.recipes.primal_dual_evolution.Model.getLPBInvARow +pyscipopt.recipes.primal_dual_evolution.Model.getLPBInvRow +pyscipopt.recipes.primal_dual_evolution.Model.getLPBasisInd +pyscipopt.recipes.primal_dual_evolution.Model.getLPBranchCands +pyscipopt.recipes.primal_dual_evolution.Model.getLPColsData +pyscipopt.recipes.primal_dual_evolution.Model.getLPObjVal +pyscipopt.recipes.primal_dual_evolution.Model.getLPRowsData +pyscipopt.recipes.primal_dual_evolution.Model.getLPSolstat +pyscipopt.recipes.primal_dual_evolution.Model.getLeaves +pyscipopt.recipes.primal_dual_evolution.Model.getLhs +pyscipopt.recipes.primal_dual_evolution.Model.getLinearConsIndicator +pyscipopt.recipes.primal_dual_evolution.Model.getLocalEstimate +pyscipopt.recipes.primal_dual_evolution.Model.getLowerbound +pyscipopt.recipes.primal_dual_evolution.Model.getMajorVersion +pyscipopt.recipes.primal_dual_evolution.Model.getMaxDepth +pyscipopt.recipes.primal_dual_evolution.Model.getMinorVersion +pyscipopt.recipes.primal_dual_evolution.Model.getNBestSolsFound +pyscipopt.recipes.primal_dual_evolution.Model.getNBinVars +pyscipopt.recipes.primal_dual_evolution.Model.getNChildren +pyscipopt.recipes.primal_dual_evolution.Model.getNConss +pyscipopt.recipes.primal_dual_evolution.Model.getNContVars +pyscipopt.recipes.primal_dual_evolution.Model.getNCountedSols +pyscipopt.recipes.primal_dual_evolution.Model.getNCuts +pyscipopt.recipes.primal_dual_evolution.Model.getNCutsApplied +pyscipopt.recipes.primal_dual_evolution.Model.getNFeasibleLeaves +pyscipopt.recipes.primal_dual_evolution.Model.getNImplVars +pyscipopt.recipes.primal_dual_evolution.Model.getNInfeasibleLeaves +pyscipopt.recipes.primal_dual_evolution.Model.getNIntVars +pyscipopt.recipes.primal_dual_evolution.Model.getNLPBranchCands +pyscipopt.recipes.primal_dual_evolution.Model.getNLPCols +pyscipopt.recipes.primal_dual_evolution.Model.getNLPIterations +pyscipopt.recipes.primal_dual_evolution.Model.getNLPRows +pyscipopt.recipes.primal_dual_evolution.Model.getNLPs +pyscipopt.recipes.primal_dual_evolution.Model.getNLeaves +pyscipopt.recipes.primal_dual_evolution.Model.getNLimSolsFound +pyscipopt.recipes.primal_dual_evolution.Model.getNNlRows +pyscipopt.recipes.primal_dual_evolution.Model.getNNodeLPIterations +pyscipopt.recipes.primal_dual_evolution.Model.getNNodes +pyscipopt.recipes.primal_dual_evolution.Model.getNReaders +pyscipopt.recipes.primal_dual_evolution.Model.getNSepaRounds +pyscipopt.recipes.primal_dual_evolution.Model.getNSiblings +pyscipopt.recipes.primal_dual_evolution.Model.getNSols +pyscipopt.recipes.primal_dual_evolution.Model.getNSolsFound +pyscipopt.recipes.primal_dual_evolution.Model.getNStrongbranchLPIterations +pyscipopt.recipes.primal_dual_evolution.Model.getNTotalNodes +pyscipopt.recipes.primal_dual_evolution.Model.getNVars +pyscipopt.recipes.primal_dual_evolution.Model.getNVarsAnd +pyscipopt.recipes.primal_dual_evolution.Model.getNlRowActivityBounds +pyscipopt.recipes.primal_dual_evolution.Model.getNlRowSolActivity +pyscipopt.recipes.primal_dual_evolution.Model.getNlRowSolFeasibility +pyscipopt.recipes.primal_dual_evolution.Model.getNlRows +pyscipopt.recipes.primal_dual_evolution.Model.getObjVal +pyscipopt.recipes.primal_dual_evolution.Model.getObjective +pyscipopt.recipes.primal_dual_evolution.Model.getObjectiveSense +pyscipopt.recipes.primal_dual_evolution.Model.getObjlimit +pyscipopt.recipes.primal_dual_evolution.Model.getObjoffset +pyscipopt.recipes.primal_dual_evolution.Model.getOpenNodes +pyscipopt.recipes.primal_dual_evolution.Model.getParam +pyscipopt.recipes.primal_dual_evolution.Model.getParams +pyscipopt.recipes.primal_dual_evolution.Model.getPlungeDepth +pyscipopt.recipes.primal_dual_evolution.Model.getPresolvingTime +pyscipopt.recipes.primal_dual_evolution.Model.getPrimalRay +pyscipopt.recipes.primal_dual_evolution.Model.getPrimalRayVal +pyscipopt.recipes.primal_dual_evolution.Model.getPrimalbound +pyscipopt.recipes.primal_dual_evolution.Model.getPrioChild +pyscipopt.recipes.primal_dual_evolution.Model.getPrioSibling +pyscipopt.recipes.primal_dual_evolution.Model.getProbName +pyscipopt.recipes.primal_dual_evolution.Model.getProbingDepth +pyscipopt.recipes.primal_dual_evolution.Model.getPseudoBranchCands +pyscipopt.recipes.primal_dual_evolution.Model.getReadingTime +pyscipopt.recipes.primal_dual_evolution.Model.getResultantAnd +pyscipopt.recipes.primal_dual_evolution.Model.getRhs +pyscipopt.recipes.primal_dual_evolution.Model.getRowActivity +pyscipopt.recipes.primal_dual_evolution.Model.getRowDualSol +pyscipopt.recipes.primal_dual_evolution.Model.getRowLPActivity +pyscipopt.recipes.primal_dual_evolution.Model.getRowLinear +pyscipopt.recipes.primal_dual_evolution.Model.getRowNumIntCols +pyscipopt.recipes.primal_dual_evolution.Model.getRowObjParallelism +pyscipopt.recipes.primal_dual_evolution.Model.getRowParallelism +pyscipopt.recipes.primal_dual_evolution.Model.getSiblings +pyscipopt.recipes.primal_dual_evolution.Model.getSlack +pyscipopt.recipes.primal_dual_evolution.Model.getSlackVarIndicator +pyscipopt.recipes.primal_dual_evolution.Model.getSolObjVal +pyscipopt.recipes.primal_dual_evolution.Model.getSolTime +pyscipopt.recipes.primal_dual_evolution.Model.getSolVal +pyscipopt.recipes.primal_dual_evolution.Model.getSols +pyscipopt.recipes.primal_dual_evolution.Model.getSolvingTime +pyscipopt.recipes.primal_dual_evolution.Model.getStage +pyscipopt.recipes.primal_dual_evolution.Model.getStageName +pyscipopt.recipes.primal_dual_evolution.Model.getStatus +pyscipopt.recipes.primal_dual_evolution.Model.getTechVersion +pyscipopt.recipes.primal_dual_evolution.Model.getTermsQuadratic +pyscipopt.recipes.primal_dual_evolution.Model.getTotalTime +pyscipopt.recipes.primal_dual_evolution.Model.getTransformedCons +pyscipopt.recipes.primal_dual_evolution.Model.getTransformedVar +pyscipopt.recipes.primal_dual_evolution.Model.getTreesizeEstimation +pyscipopt.recipes.primal_dual_evolution.Model.getVal +pyscipopt.recipes.primal_dual_evolution.Model.getValsLinear +pyscipopt.recipes.primal_dual_evolution.Model.getVarDict +pyscipopt.recipes.primal_dual_evolution.Model.getVarLbDive +pyscipopt.recipes.primal_dual_evolution.Model.getVarPseudocost +pyscipopt.recipes.primal_dual_evolution.Model.getVarPseudocostScore +pyscipopt.recipes.primal_dual_evolution.Model.getVarRedcost +pyscipopt.recipes.primal_dual_evolution.Model.getVarStrongbranch +pyscipopt.recipes.primal_dual_evolution.Model.getVarStrongbranchLast +pyscipopt.recipes.primal_dual_evolution.Model.getVarStrongbranchNode +pyscipopt.recipes.primal_dual_evolution.Model.getVarUbDive +pyscipopt.recipes.primal_dual_evolution.Model.getVars +pyscipopt.recipes.primal_dual_evolution.Model.getVarsAnd +pyscipopt.recipes.primal_dual_evolution.Model.getWeightsKnapsack +pyscipopt.recipes.primal_dual_evolution.Model.hasPrimalRay +pyscipopt.recipes.primal_dual_evolution.Model.hideOutput +pyscipopt.recipes.primal_dual_evolution.Model.inProbing +pyscipopt.recipes.primal_dual_evolution.Model.inRepropagation +pyscipopt.recipes.primal_dual_evolution.Model.includeBenders +pyscipopt.recipes.primal_dual_evolution.Model.includeBendersDefaultCuts +pyscipopt.recipes.primal_dual_evolution.Model.includeBenderscut +pyscipopt.recipes.primal_dual_evolution.Model.includeBranchrule +pyscipopt.recipes.primal_dual_evolution.Model.includeConshdlr +pyscipopt.recipes.primal_dual_evolution.Model.includeCutsel +pyscipopt.recipes.primal_dual_evolution.Model.includeDefaultPlugins +pyscipopt.recipes.primal_dual_evolution.Model.includeEventhdlr +pyscipopt.recipes.primal_dual_evolution.Model.includeHeur +pyscipopt.recipes.primal_dual_evolution.Model.includeIISfinder +pyscipopt.recipes.primal_dual_evolution.Model.includeNodesel +pyscipopt.recipes.primal_dual_evolution.Model.includePresol +pyscipopt.recipes.primal_dual_evolution.Model.includePricer +pyscipopt.recipes.primal_dual_evolution.Model.includeProp +pyscipopt.recipes.primal_dual_evolution.Model.includeReader +pyscipopt.recipes.primal_dual_evolution.Model.includeRelax +pyscipopt.recipes.primal_dual_evolution.Model.includeSepa +pyscipopt.recipes.primal_dual_evolution.Model.infinity +pyscipopt.recipes.primal_dual_evolution.Model.initBendersDefault +pyscipopt.recipes.primal_dual_evolution.Model.interruptSolve +pyscipopt.recipes.primal_dual_evolution.Model.isAndConsSorted +pyscipopt.recipes.primal_dual_evolution.Model.isCutEfficacious +pyscipopt.recipes.primal_dual_evolution.Model.isEQ +pyscipopt.recipes.primal_dual_evolution.Model.isExact +pyscipopt.recipes.primal_dual_evolution.Model.isFeasEQ +pyscipopt.recipes.primal_dual_evolution.Model.isFeasGE +pyscipopt.recipes.primal_dual_evolution.Model.isFeasGT +pyscipopt.recipes.primal_dual_evolution.Model.isFeasIntegral +pyscipopt.recipes.primal_dual_evolution.Model.isFeasLE +pyscipopt.recipes.primal_dual_evolution.Model.isFeasLT +pyscipopt.recipes.primal_dual_evolution.Model.isFeasNegative +pyscipopt.recipes.primal_dual_evolution.Model.isFeasPositive +pyscipopt.recipes.primal_dual_evolution.Model.isFeasZero +pyscipopt.recipes.primal_dual_evolution.Model.isGE +pyscipopt.recipes.primal_dual_evolution.Model.isGT +pyscipopt.recipes.primal_dual_evolution.Model.isHugeValue +pyscipopt.recipes.primal_dual_evolution.Model.isInfinity +pyscipopt.recipes.primal_dual_evolution.Model.isLE +pyscipopt.recipes.primal_dual_evolution.Model.isLPSolBasic +pyscipopt.recipes.primal_dual_evolution.Model.isLT +pyscipopt.recipes.primal_dual_evolution.Model.isNLPConstructed +pyscipopt.recipes.primal_dual_evolution.Model.isNegative +pyscipopt.recipes.primal_dual_evolution.Model.isObjChangedProbing +pyscipopt.recipes.primal_dual_evolution.Model.isPositive +pyscipopt.recipes.primal_dual_evolution.Model.isZero +pyscipopt.recipes.primal_dual_evolution.Model.lpiGetIterations +pyscipopt.recipes.primal_dual_evolution.Model.markDoNotAggrVar +pyscipopt.recipes.primal_dual_evolution.Model.markDoNotMultaggrVar +pyscipopt.recipes.primal_dual_evolution.Model.newProbingNode +pyscipopt.recipes.primal_dual_evolution.Model.optimize +pyscipopt.recipes.primal_dual_evolution.Model.optimizeNogil +pyscipopt.recipes.primal_dual_evolution.Model.presolve +pyscipopt.recipes.primal_dual_evolution.Model.printBestSol +pyscipopt.recipes.primal_dual_evolution.Model.printCons +pyscipopt.recipes.primal_dual_evolution.Model.printExternalCodeVersions +pyscipopt.recipes.primal_dual_evolution.Model.printNlRow +pyscipopt.recipes.primal_dual_evolution.Model.printProblem +pyscipopt.recipes.primal_dual_evolution.Model.printRow +pyscipopt.recipes.primal_dual_evolution.Model.printSol +pyscipopt.recipes.primal_dual_evolution.Model.printStatistics +pyscipopt.recipes.primal_dual_evolution.Model.printStatisticsJson +pyscipopt.recipes.primal_dual_evolution.Model.printVersion +pyscipopt.recipes.primal_dual_evolution.Model.propagateProbing +pyscipopt.recipes.primal_dual_evolution.Model.readParams +pyscipopt.recipes.primal_dual_evolution.Model.readProblem +pyscipopt.recipes.primal_dual_evolution.Model.readSol +pyscipopt.recipes.primal_dual_evolution.Model.readSolFile +pyscipopt.recipes.primal_dual_evolution.Model.redirectOutput +pyscipopt.recipes.primal_dual_evolution.Model.relax +pyscipopt.recipes.primal_dual_evolution.Model.releaseRow +pyscipopt.recipes.primal_dual_evolution.Model.repropagateNode +pyscipopt.recipes.primal_dual_evolution.Model.resetParam +pyscipopt.recipes.primal_dual_evolution.Model.resetParams +pyscipopt.recipes.primal_dual_evolution.Model.restartSolve +pyscipopt.recipes.primal_dual_evolution.Model.separateSol +pyscipopt.recipes.primal_dual_evolution.Model.setBendersSubproblemIsConvex +pyscipopt.recipes.primal_dual_evolution.Model.setBoolParam +pyscipopt.recipes.primal_dual_evolution.Model.setCharParam +pyscipopt.recipes.primal_dual_evolution.Model.setCheck +pyscipopt.recipes.primal_dual_evolution.Model.setEmphasis +pyscipopt.recipes.primal_dual_evolution.Model.setEnforced +pyscipopt.recipes.primal_dual_evolution.Model.setHeurTiming +pyscipopt.recipes.primal_dual_evolution.Model.setHeuristics +pyscipopt.recipes.primal_dual_evolution.Model.setInitial +pyscipopt.recipes.primal_dual_evolution.Model.setIntParam +pyscipopt.recipes.primal_dual_evolution.Model.setLogfile +pyscipopt.recipes.primal_dual_evolution.Model.setLongintParam +pyscipopt.recipes.primal_dual_evolution.Model.setMaximize +pyscipopt.recipes.primal_dual_evolution.Model.setMinimize +pyscipopt.recipes.primal_dual_evolution.Model.setModifiable +pyscipopt.recipes.primal_dual_evolution.Model.setObjIntegral +pyscipopt.recipes.primal_dual_evolution.Model.setObjective +pyscipopt.recipes.primal_dual_evolution.Model.setObjlimit +pyscipopt.recipes.primal_dual_evolution.Model.setParam +pyscipopt.recipes.primal_dual_evolution.Model.setParams +pyscipopt.recipes.primal_dual_evolution.Model.setParamsCountsols +pyscipopt.recipes.primal_dual_evolution.Model.setPresolve +pyscipopt.recipes.primal_dual_evolution.Model.setProbName +pyscipopt.recipes.primal_dual_evolution.Model.setRealParam +pyscipopt.recipes.primal_dual_evolution.Model.setRelaxSolVal +pyscipopt.recipes.primal_dual_evolution.Model.setRemovable +pyscipopt.recipes.primal_dual_evolution.Model.setSeparating +pyscipopt.recipes.primal_dual_evolution.Model.setSolVal +pyscipopt.recipes.primal_dual_evolution.Model.setStringParam +pyscipopt.recipes.primal_dual_evolution.Model.setupBendersSubproblem +pyscipopt.recipes.primal_dual_evolution.Model.solveBendersSubproblem +pyscipopt.recipes.primal_dual_evolution.Model.solveConcurrent +pyscipopt.recipes.primal_dual_evolution.Model.solveDiveLP +pyscipopt.recipes.primal_dual_evolution.Model.solveProbingLP +pyscipopt.recipes.primal_dual_evolution.Model.sortAndCons +pyscipopt.recipes.primal_dual_evolution.Model.startDive +pyscipopt.recipes.primal_dual_evolution.Model.startProbing +pyscipopt.recipes.primal_dual_evolution.Model.startStrongbranch +pyscipopt.recipes.primal_dual_evolution.Model.tightenVarLb +pyscipopt.recipes.primal_dual_evolution.Model.tightenVarLbGlobal +pyscipopt.recipes.primal_dual_evolution.Model.tightenVarUb +pyscipopt.recipes.primal_dual_evolution.Model.tightenVarUbGlobal +pyscipopt.recipes.primal_dual_evolution.Model.to_ptr +pyscipopt.recipes.primal_dual_evolution.Model.translateSubSol +pyscipopt.recipes.primal_dual_evolution.Model.trySol +pyscipopt.recipes.primal_dual_evolution.Model.updateBendersLowerbounds +pyscipopt.recipes.primal_dual_evolution.Model.updateNodeLowerbound +pyscipopt.recipes.primal_dual_evolution.Model.updateVarPseudocost +pyscipopt.recipes.primal_dual_evolution.Model.version +pyscipopt.recipes.primal_dual_evolution.Model.writeBestSol +pyscipopt.recipes.primal_dual_evolution.Model.writeBestTransSol +pyscipopt.recipes.primal_dual_evolution.Model.writeLP +pyscipopt.recipes.primal_dual_evolution.Model.writeMIP +pyscipopt.recipes.primal_dual_evolution.Model.writeName +pyscipopt.recipes.primal_dual_evolution.Model.writeParams +pyscipopt.recipes.primal_dual_evolution.Model.writeProblem +pyscipopt.recipes.primal_dual_evolution.Model.writeSol +pyscipopt.recipes.primal_dual_evolution.Model.writeStatistics +pyscipopt.recipes.primal_dual_evolution.Model.writeStatisticsJson +pyscipopt.recipes.primal_dual_evolution.Model.writeTransSol +pyscipopt.recipes.primal_dual_evolution.SCIP_EVENTTYPE.__init__ +pyscipopt.scip.Benders +pyscipopt.scip.Benders.__init__ +pyscipopt.scip.Benders.benderscreatesub +pyscipopt.scip.Benders.bendersexit +pyscipopt.scip.Benders.bendersexitpre +pyscipopt.scip.Benders.bendersexitsol +pyscipopt.scip.Benders.bendersfree +pyscipopt.scip.Benders.bendersfreesub +pyscipopt.scip.Benders.bendersgetvar +pyscipopt.scip.Benders.bendersinit +pyscipopt.scip.Benders.bendersinitpre +pyscipopt.scip.Benders.bendersinitsol +pyscipopt.scip.Benders.benderspostsolve +pyscipopt.scip.Benders.benderspresubsolve +pyscipopt.scip.Benders.benderssolvesub +pyscipopt.scip.Benders.benderssolvesubconvex +pyscipopt.scip.Benderscut +pyscipopt.scip.Benderscut.__init__ +pyscipopt.scip.Benderscut.benderscutexec +pyscipopt.scip.Benderscut.benderscutexit +pyscipopt.scip.Benderscut.benderscutexitsol +pyscipopt.scip.Benderscut.benderscutfree +pyscipopt.scip.Benderscut.benderscutinit +pyscipopt.scip.Benderscut.benderscutinitsol +pyscipopt.scip.BoundChange +pyscipopt.scip.BoundChange.__init__ +pyscipopt.scip.BoundChange.getBoundchgtype +pyscipopt.scip.BoundChange.getBoundtype +pyscipopt.scip.BoundChange.getNewBound +pyscipopt.scip.BoundChange.getVar +pyscipopt.scip.BoundChange.isRedundant +pyscipopt.scip.Branchrule +pyscipopt.scip.Branchrule.__init__ +pyscipopt.scip.Branchrule.branchexecext +pyscipopt.scip.Branchrule.branchexeclp +pyscipopt.scip.Branchrule.branchexecps +pyscipopt.scip.Branchrule.branchexit +pyscipopt.scip.Branchrule.branchexitsol +pyscipopt.scip.Branchrule.branchfree +pyscipopt.scip.Branchrule.branchinit +pyscipopt.scip.Branchrule.branchinitsol +pyscipopt.scip.Column +pyscipopt.scip.Column.__init__ +pyscipopt.scip.Column.getAge +pyscipopt.scip.Column.getBasisStatus +pyscipopt.scip.Column.getLPPos +pyscipopt.scip.Column.getLb +pyscipopt.scip.Column.getObjCoeff +pyscipopt.scip.Column.getPrimsol +pyscipopt.scip.Column.getUb +pyscipopt.scip.Column.getVar +pyscipopt.scip.Column.isIntegral +pyscipopt.scip.ColumnExact +pyscipopt.scip.ColumnExact.__init__ +pyscipopt.scip.Conshdlr +pyscipopt.scip.Conshdlr.__init__ +pyscipopt.scip.Conshdlr.consactive +pyscipopt.scip.Conshdlr.conscheck +pyscipopt.scip.Conshdlr.conscopy +pyscipopt.scip.Conshdlr.consdeactive +pyscipopt.scip.Conshdlr.consdelete +pyscipopt.scip.Conshdlr.consdelvars +pyscipopt.scip.Conshdlr.consdisable +pyscipopt.scip.Conshdlr.consenable +pyscipopt.scip.Conshdlr.consenfolp +pyscipopt.scip.Conshdlr.consenfops +pyscipopt.scip.Conshdlr.consenforelax +pyscipopt.scip.Conshdlr.consexit +pyscipopt.scip.Conshdlr.consexitpre +pyscipopt.scip.Conshdlr.consexitsol +pyscipopt.scip.Conshdlr.consfree +pyscipopt.scip.Conshdlr.consgetdivebdchgs +pyscipopt.scip.Conshdlr.consgetnvars +pyscipopt.scip.Conshdlr.consgetpermsymgraph +pyscipopt.scip.Conshdlr.consgetsignedpermsymgraph +pyscipopt.scip.Conshdlr.consgetvars +pyscipopt.scip.Conshdlr.consinit +pyscipopt.scip.Conshdlr.consinitlp +pyscipopt.scip.Conshdlr.consinitpre +pyscipopt.scip.Conshdlr.consinitsol +pyscipopt.scip.Conshdlr.conslock +pyscipopt.scip.Conshdlr.consparse +pyscipopt.scip.Conshdlr.conspresol +pyscipopt.scip.Conshdlr.consprint +pyscipopt.scip.Conshdlr.consprop +pyscipopt.scip.Conshdlr.consresprop +pyscipopt.scip.Conshdlr.conssepalp +pyscipopt.scip.Conshdlr.conssepasol +pyscipopt.scip.Conshdlr.constrans +pyscipopt.scip.Constant +pyscipopt.scip.Constraint +pyscipopt.scip.Constraint.__init__ +pyscipopt.scip.Constraint.getConshdlrName +pyscipopt.scip.Constraint.isActive +pyscipopt.scip.Constraint.isChecked +pyscipopt.scip.Constraint.isDynamic +pyscipopt.scip.Constraint.isEnforced +pyscipopt.scip.Constraint.isInitial +pyscipopt.scip.Constraint.isKnapsack +pyscipopt.scip.Constraint.isLinear +pyscipopt.scip.Constraint.isLinearType +pyscipopt.scip.Constraint.isLocal +pyscipopt.scip.Constraint.isModifiable +pyscipopt.scip.Constraint.isNonlinear +pyscipopt.scip.Constraint.isOriginal +pyscipopt.scip.Constraint.isPropagated +pyscipopt.scip.Constraint.isRemovable +pyscipopt.scip.Constraint.isSeparated +pyscipopt.scip.Constraint.isStickingAtNode +pyscipopt.scip.Cutsel +pyscipopt.scip.Cutsel.__init__ +pyscipopt.scip.Cutsel.cutselexit +pyscipopt.scip.Cutsel.cutselexitsol +pyscipopt.scip.Cutsel.cutselfree +pyscipopt.scip.Cutsel.cutselinit +pyscipopt.scip.Cutsel.cutselinitsol +pyscipopt.scip.Cutsel.cutselselect +pyscipopt.scip.DomainChanges +pyscipopt.scip.DomainChanges.__init__ +pyscipopt.scip.DomainChanges.getBoundchgs +pyscipopt.scip.Event +pyscipopt.scip.Event.__init__ +pyscipopt.scip.Event._getEventNames +pyscipopt.scip.Event.getName +pyscipopt.scip.Event.getNewBound +pyscipopt.scip.Event.getNode +pyscipopt.scip.Event.getOldBound +pyscipopt.scip.Event.getRow +pyscipopt.scip.Event.getType +pyscipopt.scip.Event.getVar +pyscipopt.scip.Eventhdlr +pyscipopt.scip.Eventhdlr.__init__ +pyscipopt.scip.Eventhdlr.eventcopy +pyscipopt.scip.Eventhdlr.eventdelete +pyscipopt.scip.Eventhdlr.eventexec +pyscipopt.scip.Eventhdlr.eventexit +pyscipopt.scip.Eventhdlr.eventexitsol +pyscipopt.scip.Eventhdlr.eventfree +pyscipopt.scip.Eventhdlr.eventinit +pyscipopt.scip.Eventhdlr.eventinitsol +pyscipopt.scip.Expr +pyscipopt.scip.Expr.__pow__ +pyscipopt.scip.Expr.degree +pyscipopt.scip.Expr.normalize +pyscipopt.scip.ExprCons +pyscipopt.scip.ExprCons.normalize +pyscipopt.scip.GenExpr +pyscipopt.scip.GenExpr.__pow__ +pyscipopt.scip.GenExpr.degree +pyscipopt.scip.GenExpr.getOp +pyscipopt.scip.Heur +pyscipopt.scip.Heur.__init__ +pyscipopt.scip.Heur.heurexec +pyscipopt.scip.Heur.heurexit +pyscipopt.scip.Heur.heurexitsol +pyscipopt.scip.Heur.heurfree +pyscipopt.scip.Heur.heurinit +pyscipopt.scip.Heur.heurinitsol +pyscipopt.scip.IIS +pyscipopt.scip.IIS.__init__ +pyscipopt.scip.IIS.getNNodes +pyscipopt.scip.IIS.getSubscip +pyscipopt.scip.IIS.getTime +pyscipopt.scip.IIS.greedyMakeIrreducible +pyscipopt.scip.IIS.isSubscipInfeasible +pyscipopt.scip.IIS.isSubscipIrreducible +pyscipopt.scip.IIS.setSubscipInfeasible +pyscipopt.scip.IIS.setSubscipIrreducible +pyscipopt.scip.IISfinder +pyscipopt.scip.IISfinder.__init__ +pyscipopt.scip.IISfinder.iisfinderexec +pyscipopt.scip.IISfinder.iisfinderfree +pyscipopt.scip.LP +pyscipopt.scip.LP.addCol +pyscipopt.scip.LP.addCols +pyscipopt.scip.LP.addRow +pyscipopt.scip.LP.addRows +pyscipopt.scip.LP.chgBound +pyscipopt.scip.LP.chgCoef +pyscipopt.scip.LP.chgObj +pyscipopt.scip.LP.chgSide +pyscipopt.scip.LP.clear +pyscipopt.scip.LP.delCols +pyscipopt.scip.LP.delRows +pyscipopt.scip.LP.getActivity +pyscipopt.scip.LP.getBasisInds +pyscipopt.scip.LP.getBounds +pyscipopt.scip.LP.getDual +pyscipopt.scip.LP.getDualRay +pyscipopt.scip.LP.getIntParam +pyscipopt.scip.LP.getNIterations +pyscipopt.scip.LP.getObjVal +pyscipopt.scip.LP.getPrimal +pyscipopt.scip.LP.getPrimalRay +pyscipopt.scip.LP.getRealParam +pyscipopt.scip.LP.getRedcost +pyscipopt.scip.LP.getSides +pyscipopt.scip.LP.infinity +pyscipopt.scip.LP.isDualFeasible +pyscipopt.scip.LP.isInfinity +pyscipopt.scip.LP.isOptimal +pyscipopt.scip.LP.isPrimalFeasible +pyscipopt.scip.LP.ncols +pyscipopt.scip.LP.nrows +pyscipopt.scip.LP.readLP +pyscipopt.scip.LP.setIntParam +pyscipopt.scip.LP.setRealParam +pyscipopt.scip.LP.solve +pyscipopt.scip.LP.writeLP +pyscipopt.scip.MatrixConstraint.getConshdlrName +pyscipopt.scip.MatrixConstraint.isActive +pyscipopt.scip.MatrixConstraint.isChecked +pyscipopt.scip.MatrixConstraint.isDynamic +pyscipopt.scip.MatrixConstraint.isEnforced +pyscipopt.scip.MatrixConstraint.isInitial +pyscipopt.scip.MatrixConstraint.isLinear +pyscipopt.scip.MatrixConstraint.isLocal +pyscipopt.scip.MatrixConstraint.isModifiable +pyscipopt.scip.MatrixConstraint.isNonlinear +pyscipopt.scip.MatrixConstraint.isPropagated +pyscipopt.scip.MatrixConstraint.isRemovable +pyscipopt.scip.MatrixConstraint.isSeparated +pyscipopt.scip.MatrixConstraint.isStickingAtNode +pyscipopt.scip.MatrixExpr.__matmul__ +pyscipopt.scip.MatrixExpr.sum +pyscipopt.scip.MatrixVariable.getAvgSol +pyscipopt.scip.MatrixVariable.getCol +pyscipopt.scip.MatrixVariable.getIndex +pyscipopt.scip.MatrixVariable.getLPSol +pyscipopt.scip.MatrixVariable.getLbGlobal +pyscipopt.scip.MatrixVariable.getLbLocal +pyscipopt.scip.MatrixVariable.getLbOriginal +pyscipopt.scip.MatrixVariable.getObj +pyscipopt.scip.MatrixVariable.getUbGlobal +pyscipopt.scip.MatrixVariable.getUbLocal +pyscipopt.scip.MatrixVariable.getUbOriginal +pyscipopt.scip.MatrixVariable.isInLP +pyscipopt.scip.MatrixVariable.varMayRound +pyscipopt.scip.MatrixVariable.vtype +pyscipopt.scip.Model +pyscipopt.scip.Model._createConsGenNonlinear +pyscipopt.scip.Model._createConsLinear +pyscipopt.scip.Model._createConsNonlinear +pyscipopt.scip.Model._createConsQuadratic +pyscipopt.scip.Model._getStageNames +pyscipopt.scip.Model.activateBenders +pyscipopt.scip.Model.addBendersSubproblem +pyscipopt.scip.Model.addCoefKnapsack +pyscipopt.scip.Model.addCoefLinear +pyscipopt.scip.Model.addCons +pyscipopt.scip.Model.addConsAnd +pyscipopt.scip.Model.addConsCardinality +pyscipopt.scip.Model.addConsCoeff +pyscipopt.scip.Model.addConsDisjunction +pyscipopt.scip.Model.addConsElemDisjunction +pyscipopt.scip.Model.addConsIndicator +pyscipopt.scip.Model.addConsKnapsack +pyscipopt.scip.Model.addConsLocal +pyscipopt.scip.Model.addConsNode +pyscipopt.scip.Model.addConsOr +pyscipopt.scip.Model.addConsSOS1 +pyscipopt.scip.Model.addConsSOS2 +pyscipopt.scip.Model.addConsXor +pyscipopt.scip.Model.addConss +pyscipopt.scip.Model.addCut +pyscipopt.scip.Model.addExprNonlinear +pyscipopt.scip.Model.addMatrixCons +pyscipopt.scip.Model.addMatrixConsIndicator +pyscipopt.scip.Model.addMatrixVar +pyscipopt.scip.Model.addObjoffset +pyscipopt.scip.Model.addPoolCut +pyscipopt.scip.Model.addPyCons +pyscipopt.scip.Model.addRowDive +pyscipopt.scip.Model.addRowExact +pyscipopt.scip.Model.addSol +pyscipopt.scip.Model.addVar +pyscipopt.scip.Model.addVarLocks +pyscipopt.scip.Model.addVarLocksType +pyscipopt.scip.Model.addVarSOS1 +pyscipopt.scip.Model.addVarSOS2 +pyscipopt.scip.Model.addVarToRow +pyscipopt.scip.Model.allColsInLP +pyscipopt.scip.Model.allowNegSlackExact +pyscipopt.scip.Model.appendVarSOS1 +pyscipopt.scip.Model.appendVarSOS2 +pyscipopt.scip.Model.applyCutsProbing +pyscipopt.scip.Model.attachEventHandlerCallback +pyscipopt.scip.Model.backtrackProbing +pyscipopt.scip.Model.branchLPExact +pyscipopt.scip.Model.branchVar +pyscipopt.scip.Model.branchVarVal +pyscipopt.scip.Model.cacheRowExtensions +pyscipopt.scip.Model.calcChildEstimate +pyscipopt.scip.Model.calcNodeselPriority +pyscipopt.scip.Model.catchEvent +pyscipopt.scip.Model.catchRowEvent +pyscipopt.scip.Model.catchVarEvent +pyscipopt.scip.Model.checkBendersSubproblemOptimality +pyscipopt.scip.Model.checkQuadraticNonlinear +pyscipopt.scip.Model.checkSol +pyscipopt.scip.Model.chgCapacityKnapsack +pyscipopt.scip.Model.chgCoefLinear +pyscipopt.scip.Model.chgLhs +pyscipopt.scip.Model.chgReoptObjective +pyscipopt.scip.Model.chgRhs +pyscipopt.scip.Model.chgRowLhsDive +pyscipopt.scip.Model.chgRowRhsDive +pyscipopt.scip.Model.chgVarBranchPriority +pyscipopt.scip.Model.chgVarLb +pyscipopt.scip.Model.chgVarLbDive +pyscipopt.scip.Model.chgVarLbGlobal +pyscipopt.scip.Model.chgVarLbNode +pyscipopt.scip.Model.chgVarLbProbing +pyscipopt.scip.Model.chgVarObjDive +pyscipopt.scip.Model.chgVarObjProbing +pyscipopt.scip.Model.chgVarType +pyscipopt.scip.Model.chgVarUb +pyscipopt.scip.Model.chgVarUbDive +pyscipopt.scip.Model.chgVarUbGlobal +pyscipopt.scip.Model.chgVarUbNode +pyscipopt.scip.Model.chgVarUbProbing +pyscipopt.scip.Model.computeBestSolSubproblems +pyscipopt.scip.Model.constructLP +pyscipopt.scip.Model.copyLargeNeighborhoodSearch +pyscipopt.scip.Model.count +pyscipopt.scip.Model.createChild +pyscipopt.scip.Model.createCons +pyscipopt.scip.Model.createConsFromExpr +pyscipopt.scip.Model.createEmptyRowSepa +pyscipopt.scip.Model.createEmptyRowUnspec +pyscipopt.scip.Model.createOrigSol +pyscipopt.scip.Model.createPartialSol +pyscipopt.scip.Model.createProbBasic +pyscipopt.scip.Model.createSol +pyscipopt.scip.Model.cutoffNode +pyscipopt.scip.Model.deactivatePricer +pyscipopt.scip.Model.delCoefLinear +pyscipopt.scip.Model.delCons +pyscipopt.scip.Model.delConsLocal +pyscipopt.scip.Model.delVar +pyscipopt.scip.Model.disableDebugSol +pyscipopt.scip.Model.disablePropagation +pyscipopt.scip.Model.dropEvent +pyscipopt.scip.Model.dropRowEvent +pyscipopt.scip.Model.dropVarEvent +pyscipopt.scip.Model.enableDebugSol +pyscipopt.scip.Model.enableExactSolving +pyscipopt.scip.Model.enableReoptimization +pyscipopt.scip.Model.endDive +pyscipopt.scip.Model.endProbing +pyscipopt.scip.Model.endStrongbranch +pyscipopt.scip.Model.epsilon +pyscipopt.scip.Model.feasCeil +pyscipopt.scip.Model.feasFloor +pyscipopt.scip.Model.feasFrac +pyscipopt.scip.Model.feasRound +pyscipopt.scip.Model.feastol +pyscipopt.scip.Model.fixVar +pyscipopt.scip.Model.fixVarProbing +pyscipopt.scip.Model.flushRowExtensions +pyscipopt.scip.Model.frac +pyscipopt.scip.Model.freeBendersSubproblems +pyscipopt.scip.Model.freeProb +pyscipopt.scip.Model.freeReoptSolve +pyscipopt.scip.Model.freeSol +pyscipopt.scip.Model.freeTransform +pyscipopt.scip.Model.from_ptr +pyscipopt.scip.Model.generateIIS +pyscipopt.scip.Model.getActivity +pyscipopt.scip.Model.getBendersAuxiliaryVar +pyscipopt.scip.Model.getBendersSubproblem +pyscipopt.scip.Model.getBendersVar +pyscipopt.scip.Model.getBestChild +pyscipopt.scip.Model.getBestLeaf +pyscipopt.scip.Model.getBestNode +pyscipopt.scip.Model.getBestSibling +pyscipopt.scip.Model.getBestSol +pyscipopt.scip.Model.getBestboundNode +pyscipopt.scip.Model.getBipartiteGraphRepresentation +pyscipopt.scip.Model.getBranchScoreMultiple +pyscipopt.scip.Model.getCapacityKnapsack +pyscipopt.scip.Model.getChildren +pyscipopt.scip.Model.getColRedCost +pyscipopt.scip.Model.getCondition +pyscipopt.scip.Model.getConsNVars +pyscipopt.scip.Model.getConsVals +pyscipopt.scip.Model.getConsVars +pyscipopt.scip.Model.getConss +pyscipopt.scip.Model.getCurrentNode +pyscipopt.scip.Model.getCutEfficacy +pyscipopt.scip.Model.getCutLPSolCutoffDistance +pyscipopt.scip.Model.getCutoffbound +pyscipopt.scip.Model.getDepth +pyscipopt.scip.Model.getDualMultiplier +pyscipopt.scip.Model.getDualSolVal +pyscipopt.scip.Model.getDualbound +pyscipopt.scip.Model.getDualboundRoot +pyscipopt.scip.Model.getDualfarkasKnapsack +pyscipopt.scip.Model.getDualfarkasLinear +pyscipopt.scip.Model.getDualsolKnapsack +pyscipopt.scip.Model.getDualsolLinear +pyscipopt.scip.Model.getGap +pyscipopt.scip.Model.getHeurTiming +pyscipopt.scip.Model.getIIS +pyscipopt.scip.Model.getLPBInvARow +pyscipopt.scip.Model.getLPBInvRow +pyscipopt.scip.Model.getLPBasisInd +pyscipopt.scip.Model.getLPBranchCands +pyscipopt.scip.Model.getLPColsData +pyscipopt.scip.Model.getLPObjVal +pyscipopt.scip.Model.getLPRowsData +pyscipopt.scip.Model.getLPSolstat +pyscipopt.scip.Model.getLeaves +pyscipopt.scip.Model.getLhs +pyscipopt.scip.Model.getLinearConsIndicator +pyscipopt.scip.Model.getLocalEstimate +pyscipopt.scip.Model.getLowerbound +pyscipopt.scip.Model.getMajorVersion +pyscipopt.scip.Model.getMaxDepth +pyscipopt.scip.Model.getMinorVersion +pyscipopt.scip.Model.getNBestSolsFound +pyscipopt.scip.Model.getNBinVars +pyscipopt.scip.Model.getNChildren +pyscipopt.scip.Model.getNConss +pyscipopt.scip.Model.getNContVars +pyscipopt.scip.Model.getNCountedSols +pyscipopt.scip.Model.getNCuts +pyscipopt.scip.Model.getNCutsApplied +pyscipopt.scip.Model.getNFeasibleLeaves +pyscipopt.scip.Model.getNImplVars +pyscipopt.scip.Model.getNInfeasibleLeaves +pyscipopt.scip.Model.getNIntVars +pyscipopt.scip.Model.getNLPBranchCands +pyscipopt.scip.Model.getNLPCols +pyscipopt.scip.Model.getNLPIterations +pyscipopt.scip.Model.getNLPRows +pyscipopt.scip.Model.getNLPs +pyscipopt.scip.Model.getNLeaves +pyscipopt.scip.Model.getNLimSolsFound +pyscipopt.scip.Model.getNNlRows +pyscipopt.scip.Model.getNNodeLPIterations +pyscipopt.scip.Model.getNNodes +pyscipopt.scip.Model.getNReaders +pyscipopt.scip.Model.getNSepaRounds +pyscipopt.scip.Model.getNSiblings +pyscipopt.scip.Model.getNSols +pyscipopt.scip.Model.getNSolsFound +pyscipopt.scip.Model.getNStrongbranchLPIterations +pyscipopt.scip.Model.getNTotalNodes +pyscipopt.scip.Model.getNVars +pyscipopt.scip.Model.getNVarsAnd +pyscipopt.scip.Model.getNlRowActivityBounds +pyscipopt.scip.Model.getNlRowSolActivity +pyscipopt.scip.Model.getNlRowSolFeasibility +pyscipopt.scip.Model.getNlRows +pyscipopt.scip.Model.getObjVal +pyscipopt.scip.Model.getObjective +pyscipopt.scip.Model.getObjectiveSense +pyscipopt.scip.Model.getObjlimit +pyscipopt.scip.Model.getObjoffset +pyscipopt.scip.Model.getOpenNodes +pyscipopt.scip.Model.getParam +pyscipopt.scip.Model.getParams +pyscipopt.scip.Model.getPlungeDepth +pyscipopt.scip.Model.getPresolvingTime +pyscipopt.scip.Model.getPrimalRay +pyscipopt.scip.Model.getPrimalRayVal +pyscipopt.scip.Model.getPrimalbound +pyscipopt.scip.Model.getPrioChild +pyscipopt.scip.Model.getPrioSibling +pyscipopt.scip.Model.getProbName +pyscipopt.scip.Model.getProbingDepth +pyscipopt.scip.Model.getPseudoBranchCands +pyscipopt.scip.Model.getReadingTime +pyscipopt.scip.Model.getResultantAnd +pyscipopt.scip.Model.getRhs +pyscipopt.scip.Model.getRowActivity +pyscipopt.scip.Model.getRowDualSol +pyscipopt.scip.Model.getRowLPActivity +pyscipopt.scip.Model.getRowLinear +pyscipopt.scip.Model.getRowNumIntCols +pyscipopt.scip.Model.getRowObjParallelism +pyscipopt.scip.Model.getRowParallelism +pyscipopt.scip.Model.getSiblings +pyscipopt.scip.Model.getSlack +pyscipopt.scip.Model.getSlackVarIndicator +pyscipopt.scip.Model.getSolObjVal +pyscipopt.scip.Model.getSolTime +pyscipopt.scip.Model.getSolVal +pyscipopt.scip.Model.getSols +pyscipopt.scip.Model.getSolvingTime +pyscipopt.scip.Model.getStage +pyscipopt.scip.Model.getStageName +pyscipopt.scip.Model.getStatus +pyscipopt.scip.Model.getTechVersion +pyscipopt.scip.Model.getTermsQuadratic +pyscipopt.scip.Model.getTotalTime +pyscipopt.scip.Model.getTransformedCons +pyscipopt.scip.Model.getTransformedVar +pyscipopt.scip.Model.getTreesizeEstimation +pyscipopt.scip.Model.getVal +pyscipopt.scip.Model.getValsLinear +pyscipopt.scip.Model.getVarDict +pyscipopt.scip.Model.getVarLbDive +pyscipopt.scip.Model.getVarPseudocost +pyscipopt.scip.Model.getVarPseudocostScore +pyscipopt.scip.Model.getVarRedcost +pyscipopt.scip.Model.getVarStrongbranch +pyscipopt.scip.Model.getVarStrongbranchLast +pyscipopt.scip.Model.getVarStrongbranchNode +pyscipopt.scip.Model.getVarUbDive +pyscipopt.scip.Model.getVars +pyscipopt.scip.Model.getVarsAnd +pyscipopt.scip.Model.getWeightsKnapsack +pyscipopt.scip.Model.hasPrimalRay +pyscipopt.scip.Model.hideOutput +pyscipopt.scip.Model.inProbing +pyscipopt.scip.Model.inRepropagation +pyscipopt.scip.Model.includeBenders +pyscipopt.scip.Model.includeBendersDefaultCuts +pyscipopt.scip.Model.includeBenderscut +pyscipopt.scip.Model.includeBranchrule +pyscipopt.scip.Model.includeConshdlr +pyscipopt.scip.Model.includeCutsel +pyscipopt.scip.Model.includeDefaultPlugins +pyscipopt.scip.Model.includeEventhdlr +pyscipopt.scip.Model.includeHeur +pyscipopt.scip.Model.includeIISfinder +pyscipopt.scip.Model.includeNodesel +pyscipopt.scip.Model.includePresol +pyscipopt.scip.Model.includePricer +pyscipopt.scip.Model.includeProp +pyscipopt.scip.Model.includeReader +pyscipopt.scip.Model.includeRelax +pyscipopt.scip.Model.includeSepa +pyscipopt.scip.Model.infinity +pyscipopt.scip.Model.initBendersDefault +pyscipopt.scip.Model.interruptSolve +pyscipopt.scip.Model.isAndConsSorted +pyscipopt.scip.Model.isCutEfficacious +pyscipopt.scip.Model.isEQ +pyscipopt.scip.Model.isExact +pyscipopt.scip.Model.isFeasEQ +pyscipopt.scip.Model.isFeasGE +pyscipopt.scip.Model.isFeasGT +pyscipopt.scip.Model.isFeasIntegral +pyscipopt.scip.Model.isFeasLE +pyscipopt.scip.Model.isFeasLT +pyscipopt.scip.Model.isFeasNegative +pyscipopt.scip.Model.isFeasPositive +pyscipopt.scip.Model.isFeasZero +pyscipopt.scip.Model.isGE +pyscipopt.scip.Model.isGT +pyscipopt.scip.Model.isHugeValue +pyscipopt.scip.Model.isInfinity +pyscipopt.scip.Model.isLE +pyscipopt.scip.Model.isLPSolBasic +pyscipopt.scip.Model.isLT +pyscipopt.scip.Model.isNLPConstructed +pyscipopt.scip.Model.isNegative +pyscipopt.scip.Model.isObjChangedProbing +pyscipopt.scip.Model.isPositive +pyscipopt.scip.Model.isZero +pyscipopt.scip.Model.lpiGetIterations +pyscipopt.scip.Model.markDoNotAggrVar +pyscipopt.scip.Model.markDoNotMultaggrVar +pyscipopt.scip.Model.newProbingNode +pyscipopt.scip.Model.optimize +pyscipopt.scip.Model.optimizeNogil +pyscipopt.scip.Model.presolve +pyscipopt.scip.Model.printBestSol +pyscipopt.scip.Model.printCons +pyscipopt.scip.Model.printExternalCodeVersions +pyscipopt.scip.Model.printNlRow +pyscipopt.scip.Model.printProblem +pyscipopt.scip.Model.printRow +pyscipopt.scip.Model.printSol +pyscipopt.scip.Model.printStatistics +pyscipopt.scip.Model.printStatisticsJson +pyscipopt.scip.Model.printVersion +pyscipopt.scip.Model.propagateProbing +pyscipopt.scip.Model.readParams +pyscipopt.scip.Model.readProblem +pyscipopt.scip.Model.readSol +pyscipopt.scip.Model.readSolFile +pyscipopt.scip.Model.redirectOutput +pyscipopt.scip.Model.relax +pyscipopt.scip.Model.releaseRow +pyscipopt.scip.Model.repropagateNode +pyscipopt.scip.Model.resetParam +pyscipopt.scip.Model.resetParams +pyscipopt.scip.Model.restartSolve +pyscipopt.scip.Model.separateSol +pyscipopt.scip.Model.setBendersSubproblemIsConvex +pyscipopt.scip.Model.setBoolParam +pyscipopt.scip.Model.setCharParam +pyscipopt.scip.Model.setCheck +pyscipopt.scip.Model.setEmphasis +pyscipopt.scip.Model.setEnforced +pyscipopt.scip.Model.setHeurTiming +pyscipopt.scip.Model.setHeuristics +pyscipopt.scip.Model.setInitial +pyscipopt.scip.Model.setIntParam +pyscipopt.scip.Model.setLogfile +pyscipopt.scip.Model.setLongintParam +pyscipopt.scip.Model.setMaximize +pyscipopt.scip.Model.setMinimize +pyscipopt.scip.Model.setModifiable +pyscipopt.scip.Model.setObjIntegral +pyscipopt.scip.Model.setObjective +pyscipopt.scip.Model.setObjlimit +pyscipopt.scip.Model.setParam +pyscipopt.scip.Model.setParams +pyscipopt.scip.Model.setParamsCountsols +pyscipopt.scip.Model.setPresolve +pyscipopt.scip.Model.setProbName +pyscipopt.scip.Model.setRealParam +pyscipopt.scip.Model.setRelaxSolVal +pyscipopt.scip.Model.setRemovable +pyscipopt.scip.Model.setSeparating +pyscipopt.scip.Model.setSolVal +pyscipopt.scip.Model.setStringParam +pyscipopt.scip.Model.setupBendersSubproblem +pyscipopt.scip.Model.solveBendersSubproblem +pyscipopt.scip.Model.solveConcurrent +pyscipopt.scip.Model.solveDiveLP +pyscipopt.scip.Model.solveProbingLP +pyscipopt.scip.Model.sortAndCons +pyscipopt.scip.Model.startDive +pyscipopt.scip.Model.startProbing +pyscipopt.scip.Model.startStrongbranch +pyscipopt.scip.Model.tightenVarLb +pyscipopt.scip.Model.tightenVarLbGlobal +pyscipopt.scip.Model.tightenVarUb +pyscipopt.scip.Model.tightenVarUbGlobal +pyscipopt.scip.Model.to_ptr +pyscipopt.scip.Model.translateSubSol +pyscipopt.scip.Model.trySol +pyscipopt.scip.Model.updateBendersLowerbounds +pyscipopt.scip.Model.updateNodeLowerbound +pyscipopt.scip.Model.updateVarPseudocost +pyscipopt.scip.Model.version +pyscipopt.scip.Model.writeBestSol +pyscipopt.scip.Model.writeBestTransSol +pyscipopt.scip.Model.writeLP +pyscipopt.scip.Model.writeMIP +pyscipopt.scip.Model.writeName +pyscipopt.scip.Model.writeParams +pyscipopt.scip.Model.writeProblem +pyscipopt.scip.Model.writeSol +pyscipopt.scip.Model.writeStatistics +pyscipopt.scip.Model.writeStatisticsJson +pyscipopt.scip.Model.writeTransSol +pyscipopt.scip.NLRow +pyscipopt.scip.NLRow.__init__ +pyscipopt.scip.NLRow.getConstant +pyscipopt.scip.NLRow.getDualsol +pyscipopt.scip.NLRow.getLhs +pyscipopt.scip.NLRow.getLinearTerms +pyscipopt.scip.NLRow.getRhs +pyscipopt.scip.Node +pyscipopt.scip.Node.__init__ +pyscipopt.scip.Node.getAddedConss +pyscipopt.scip.Node.getDepth +pyscipopt.scip.Node.getDomchg +pyscipopt.scip.Node.getEstimate +pyscipopt.scip.Node.getLowerbound +pyscipopt.scip.Node.getNAddedConss +pyscipopt.scip.Node.getNDomchg +pyscipopt.scip.Node.getNParentBranchings +pyscipopt.scip.Node.getNumber +pyscipopt.scip.Node.getParent +pyscipopt.scip.Node.getParentBranchings +pyscipopt.scip.Node.getType +pyscipopt.scip.Node.isActive +pyscipopt.scip.Node.isPropagatedAgain +pyscipopt.scip.Nodesel +pyscipopt.scip.Nodesel.__init__ +pyscipopt.scip.Nodesel.nodecomp +pyscipopt.scip.Nodesel.nodeexit +pyscipopt.scip.Nodesel.nodeexitsol +pyscipopt.scip.Nodesel.nodefree +pyscipopt.scip.Nodesel.nodeinit +pyscipopt.scip.Nodesel.nodeinitsol +pyscipopt.scip.Nodesel.nodeselect +pyscipopt.scip.PY_SCIP_BENDERSENFOTYPE.__init__ +pyscipopt.scip.PY_SCIP_BRANCHDIR.__init__ +pyscipopt.scip.PY_SCIP_EVENTTYPE.__init__ +pyscipopt.scip.PY_SCIP_HEURTIMING.__init__ +pyscipopt.scip.PY_SCIP_IMPLINTTYPE.__init__ +pyscipopt.scip.PY_SCIP_LOCKTYPE.__init__ +pyscipopt.scip.PY_SCIP_LPPARAM.__init__ +pyscipopt.scip.PY_SCIP_LPSOLSTAT.__init__ +pyscipopt.scip.PY_SCIP_NODETYPE.__init__ +pyscipopt.scip.PY_SCIP_PARAMEMPHASIS.__init__ +pyscipopt.scip.PY_SCIP_PARAMSETTING.__init__ +pyscipopt.scip.PY_SCIP_PRESOLTIMING.__init__ +pyscipopt.scip.PY_SCIP_PROPTIMING.__init__ +pyscipopt.scip.PY_SCIP_RESULT.__init__ +pyscipopt.scip.PY_SCIP_ROWORIGINTYPE.__init__ +pyscipopt.scip.PY_SCIP_SOLORIGIN.__init__ +pyscipopt.scip.PY_SCIP_STAGE.__init__ +pyscipopt.scip.PY_SCIP_STATUS.__init__ +pyscipopt.scip.PowExpr +pyscipopt.scip.Presol +pyscipopt.scip.Presol.__init__ +pyscipopt.scip.Presol.presolexec +pyscipopt.scip.Presol.presolexit +pyscipopt.scip.Presol.presolexitpre +pyscipopt.scip.Presol.presolfree +pyscipopt.scip.Presol.presolinit +pyscipopt.scip.Presol.presolinitpre +pyscipopt.scip.Pricer +pyscipopt.scip.Pricer.__init__ +pyscipopt.scip.Pricer.pricerexit +pyscipopt.scip.Pricer.pricerexitsol +pyscipopt.scip.Pricer.pricerfarkas +pyscipopt.scip.Pricer.pricerfree +pyscipopt.scip.Pricer.pricerinit +pyscipopt.scip.Pricer.pricerinitsol +pyscipopt.scip.Pricer.pricerredcost +pyscipopt.scip.ProdExpr +pyscipopt.scip.Prop +pyscipopt.scip.Prop.__init__ +pyscipopt.scip.Prop.propexec +pyscipopt.scip.Prop.propexit +pyscipopt.scip.Prop.propexitpre +pyscipopt.scip.Prop.propexitsol +pyscipopt.scip.Prop.propfree +pyscipopt.scip.Prop.propinit +pyscipopt.scip.Prop.propinitpre +pyscipopt.scip.Prop.propinitsol +pyscipopt.scip.Prop.proppresol +pyscipopt.scip.Prop.propresprop +pyscipopt.scip.Reader +pyscipopt.scip.Reader.__init__ +pyscipopt.scip.Reader.readerfree +pyscipopt.scip.Reader.readerread +pyscipopt.scip.Reader.readerwrite +pyscipopt.scip.Relax +pyscipopt.scip.Relax.__init__ +pyscipopt.scip.Relax.relaxexec +pyscipopt.scip.Relax.relaxexit +pyscipopt.scip.Relax.relaxexitsol +pyscipopt.scip.Relax.relaxfree +pyscipopt.scip.Relax.relaxinit +pyscipopt.scip.Relax.relaxinitsol +pyscipopt.scip.Row +pyscipopt.scip.Row.__init__ +pyscipopt.scip.Row.getAge +pyscipopt.scip.Row.getBasisStatus +pyscipopt.scip.Row.getCols +pyscipopt.scip.Row.getConsOriginConshdlrtype +pyscipopt.scip.Row.getConstant +pyscipopt.scip.Row.getDualfarkas +pyscipopt.scip.Row.getDualsol +pyscipopt.scip.Row.getLPPos +pyscipopt.scip.Row.getLhs +pyscipopt.scip.Row.getNLPNonz +pyscipopt.scip.Row.getNNonz +pyscipopt.scip.Row.getNorm +pyscipopt.scip.Row.getOrigintype +pyscipopt.scip.Row.getRhs +pyscipopt.scip.Row.getVals +pyscipopt.scip.Row.isInGlobalCutpool +pyscipopt.scip.Row.isIntegral +pyscipopt.scip.Row.isLocal +pyscipopt.scip.Row.isModifiable +pyscipopt.scip.Row.isRemovable +pyscipopt.scip.RowExact +pyscipopt.scip.RowExact.__init__ +pyscipopt.scip.Sepa +pyscipopt.scip.Sepa.__init__ +pyscipopt.scip.Sepa.sepaexeclp +pyscipopt.scip.Sepa.sepaexecsol +pyscipopt.scip.Sepa.sepaexit +pyscipopt.scip.Sepa.sepaexitsol +pyscipopt.scip.Sepa.sepafree +pyscipopt.scip.Sepa.sepainit +pyscipopt.scip.Sepa.sepainitsol +pyscipopt.scip.Solution +pyscipopt.scip.Solution._checkStage +pyscipopt.scip.Solution._evaluate +pyscipopt.scip.Solution.getOrigin +pyscipopt.scip.Solution.retransform +pyscipopt.scip.Solution.translate +pyscipopt.scip.Statistics.__init__ +pyscipopt.scip.Statistics.__match_args__ +pyscipopt.scip.SumExpr +pyscipopt.scip.Term.__init__ +pyscipopt.scip.VarExpr +pyscipopt.scip.Variable +pyscipopt.scip.Variable.getAvgSol +pyscipopt.scip.Variable.getCol +pyscipopt.scip.Variable.getImplType +pyscipopt.scip.Variable.getIndex +pyscipopt.scip.Variable.getLPSol +pyscipopt.scip.Variable.getLbGlobal +pyscipopt.scip.Variable.getLbLocal +pyscipopt.scip.Variable.getLbOriginal +pyscipopt.scip.Variable.getNBranchings +pyscipopt.scip.Variable.getNBranchingsCurrentRun +pyscipopt.scip.Variable.getNLocksDown +pyscipopt.scip.Variable.getNLocksDownType +pyscipopt.scip.Variable.getNLocksUp +pyscipopt.scip.Variable.getNLocksUpType +pyscipopt.scip.Variable.getObj +pyscipopt.scip.Variable.getStatus +pyscipopt.scip.Variable.getUbGlobal +pyscipopt.scip.Variable.getUbLocal +pyscipopt.scip.Variable.getUbOriginal +pyscipopt.scip.Variable.isActive +pyscipopt.scip.Variable.isBinary +pyscipopt.scip.Variable.isDeletable +pyscipopt.scip.Variable.isImpliedIntegral +pyscipopt.scip.Variable.isInLP +pyscipopt.scip.Variable.isIntegral +pyscipopt.scip.Variable.isNonImpliedIntegral +pyscipopt.scip.Variable.isOriginal +pyscipopt.scip.Variable.isRelaxationOnly +pyscipopt.scip.Variable.markRelaxationOnly +pyscipopt.scip.Variable.ptr +pyscipopt.scip.Variable.varMayRound +pyscipopt.scip.Variable.vtype +pyscipopt.scip._VarArray +pyscipopt.scip._VarArray.__init__ From 0a63048fad27a26d8ba77eb96e7363af236321bf Mon Sep 17 00:00:00 2001 From: 40% Date: Wed, 31 Dec 2025 00:41:04 +0800 Subject: [PATCH 02/15] Speed up `MatrixExpr.sum(axis=...)` via `quicksum` (#1135) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Add test for matrix sum return type Adds a test to ensure that summing a matrix variable along an axis returns a MatrixExpr type instead of MatrixVariable, addressing issue #1117. * return `MatrixExpr` type * Update CHANGELOG.md * Speed up `MatrixExpr.sum(axis=...)` Enhanced the MatrixExpr.sum method to accept axis as int or tuple, handle keepdims, and provide better error checking for axis bounds. This improves compatibility with numpy's sum behavior and allows more flexible summation over matrix expressions. * Test `MatrixExpr.sum(axis=...)` Removed n=200 from the sum performance test to limit test size. Added additional performance assertions comparing np.ndarray.sum and the optimized sum method for matrix variables. * Test `MatrixExpr.sum(axis=tuple(range(ndim))` Renamed test_matrix_sum_argument to test_matrix_sum_axis and updated tests to use explicit axis arguments in sum operations. This clarifies the behavior when summing over all axes and improves test coverage for axis handling. * Refactor MatrixExpr.sum axis handling with numpy utility Replaces manual axis validation and normalization in MatrixExpr.sum with numpy's normalize_axis_tuple for improved reliability and code clarity. Updates type hints and simplifies logic for summing across all axes. * Add tests for matrix sum error Added tests to verify error handling in matrix variable sum operations for invalid axis types, out-of-range values, and duplicate axes. * Add tests for matrix sum with keepdims parameter Introduces test cases to verify the shape of matrix variable sums when using the keepdims argument, ensuring correct behavior for both full and axis-specific summation. * call `.sum` via positional argument Replaces the use of the 'axis' keyword argument with a positional argument in the z.sum() method call to align with the expected function signature. * Refactor sum method to use np.apply_along_axis Replaces np.fromiter with np.apply_along_axis for summing along specified axes in MatrixExpr. This simplifies the code and improves readability. * Directly test the `.sum` result Added a comment to clarify the purpose of the test_matrix_sum_axis function, indicating it compares the result of summing a matrix variable after optimization. * Update CHANGELOG.md * Expand docstring for MatrixExpr.sum method The docstring for the MatrixExpr.sum method was updated to provide detailed information about parameters, return values, and behavior, improving clarity and alignment with numpy conventions. * Clarify MatrixExpr.sum docstring and note quicksum usage Updated the docstring for MatrixExpr.sum to specify that it uses quicksum for speed optimization instead of numpy.ndarray.sum. Added a detailed note explaining the difference between quicksum (using __iadd__) and numpy's sum (using __add__). * Split up two costing time test cases Renamed the existing performance test to clarify it tests the case where axis is None. Added a new test to measure performance when summing along a specific axis. * Supports numpy 1.x Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Supports Python 3.8 * Simplify a bit Refactored the sum method in MatrixExpr to clarify axis typing and simplify the application of np.apply_along_axis. The new implementation improves readability and maintains the intended behavior. * suggestion --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Co-authored-by: Joao-Dionisio Co-authored-by: João Dionísio <57299939+Joao-Dionisio@users.noreply.github.com> --- CHANGELOG.md | 2 + src/pyscipopt/matrix.pxi | 69 ++++++++++++++++++++++++---- tests/test_matrix_variable.py | 86 ++++++++++++++++++++++++++++++++--- 3 files changed, 141 insertions(+), 16 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0ab002ee6..5a94d66b0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,8 +2,10 @@ ## Unreleased ### Added +- Speed up MatrixExpr.sum(axis=...) via quicksum ### Fixed - all fundamental callbacks now raise an error if not implemented +- Fixed the type of MatrixExpr.sum(axis=...) result from MatrixVariable to MatrixExpr. ### Changed - changed default value of enablepricing flag to True ### Removed diff --git a/src/pyscipopt/matrix.pxi b/src/pyscipopt/matrix.pxi index 8353ed767..1a6a09cf3 100644 --- a/src/pyscipopt/matrix.pxi +++ b/src/pyscipopt/matrix.pxi @@ -3,8 +3,14 @@ # TODO Add tests """ +from typing import Optional, Tuple, Union import numpy as np -from typing import Union +try: + # NumPy 2.x location + from numpy.lib.array_utils import normalize_axis_tuple +except ImportError: + # Fallback for NumPy 1.x + from numpy.core.numeric import normalize_axis_tuple def _is_number(e): @@ -44,16 +50,61 @@ def _matrixexpr_richcmp(self, other, op): class MatrixExpr(np.ndarray): - def sum(self, **kwargs): - """ - Based on `numpy.ndarray.sum`, but returns a scalar if `axis=None`. - This is useful for matrix expressions to compare with a matrix or a scalar. + + def sum( + self, + axis: Optional[Union[int, Tuple[int, ...]]] = None, + keepdims: bool = False, + **kwargs, + ) -> Union[Expr, MatrixExpr]: """ + Return the sum of the array elements over the given axis. + + Parameters + ---------- + axis : None or int or tuple of ints, optional + Axis or axes along which a sum is performed. The default, axis=None, will + sum all of the elements of the input array. If axis is negative it counts + from the last to the first axis. If axis is a tuple of ints, a sum is + performed on all of the axes specified in the tuple instead of a single axis + or all the axes as before. + + keepdims : bool, optional + If this is set to True, the axes which are reduced are left in the result as + dimensions with size one. With this option, the result will broadcast + correctly against the input array. + + **kwargs : ignored + Additional keyword arguments are ignored. They exist for compatibility + with `numpy.ndarray.sum`. + + Returns + ------- + Expr or MatrixExpr + If the sum is performed over all axes, return an Expr, otherwise return + a MatrixExpr. - if kwargs.get("axis") is None: - # Speed up `.sum()` #1070 - return quicksum(self.flat) - return super().sum(**kwargs) + """ + axis: Tuple[int, ...] = normalize_axis_tuple( + range(self.ndim) if axis is None else axis, self.ndim + ) + if len(axis) == self.ndim: + res = quicksum(self.flat) + return ( + np.array([res], dtype=object).reshape([1] * self.ndim).view(MatrixExpr) + if keepdims + else res + ) + + keep_axes = tuple(i for i in range(self.ndim) if i not in axis) + shape = ( + tuple(1 if i in axis else self.shape[i] for i in range(self.ndim)) + if keepdims + else tuple(self.shape[i] for i in keep_axes) + ) + return np.apply_along_axis( + quicksum, -1, self.transpose(keep_axes + axis).reshape(shape + (-1,)) + ).view(MatrixExpr) def __le__(self, other: Union[float, int, "Expr", np.ndarray, "MatrixExpr"]) -> MatrixExprCons: return _matrixexpr_richcmp(self, other, 1) diff --git a/tests/test_matrix_variable.py b/tests/test_matrix_variable.py index 27f549000..e4758f077 100644 --- a/tests/test_matrix_variable.py +++ b/tests/test_matrix_variable.py @@ -19,7 +19,7 @@ sin, sqrt, ) -from pyscipopt.scip import GenExpr +from pyscipopt.scip import CONST, GenExpr def test_catching_errors(): @@ -181,7 +181,30 @@ def test_expr_from_matrix_vars(): for term, coeff in expr_list: assert len(term) == 3 -def test_matrix_sum_argument(): + +def test_matrix_sum_error(): + m = Model() + x = m.addMatrixVar((2, 3), "x", "I", ub=4) + + # test axis type + with pytest.raises(TypeError): + x.sum("0") + + # test axis value (out of range) + with pytest.raises(ValueError): + x.sum(2) + + # test axis value (out of range) + with pytest.raises(ValueError): + x.sum((-3,)) + + # test axis value (duplicate) + with pytest.raises(ValueError): + x.sum((0, 0)) + + +def test_matrix_sum_axis(): + # compare the result of summing matrix variable after optimization m = Model() # Return a array when axis isn't None @@ -190,7 +213,8 @@ def test_matrix_sum_argument(): # compare the result of summing 2d array to a scalar with a scalar x = m.addMatrixVar((2, 3), "x", "I", ub=4) - m.addMatrixCons(x.sum() == 24) + # `axis=tuple(range(x.ndim))` is `axis=None` + m.addMatrixCons(x.sum(axis=tuple(range(x.ndim))) == 24) # compare the result of summing 2d array to 1d array y = m.addMatrixVar((2, 4), "y", "I", ub=4) @@ -198,21 +222,43 @@ def test_matrix_sum_argument(): # compare the result of summing 3d array to a 2d array with a 2d array z = m.addMatrixVar((2, 3, 4), "z", "I", ub=4) - m.addMatrixCons(z.sum(axis=2) == x) + m.addMatrixCons(z.sum(2) == x) m.addMatrixCons(z.sum(axis=1) == y) # to fix the element values m.addMatrixCons(z == np.ones((2, 3, 4))) - m.setObjective(x.sum() + y.sum() + z.sum(), "maximize") + m.setObjective(x.sum() + y.sum() + z.sum(tuple(range(z.ndim))), "maximize") m.optimize() assert (m.getVal(x) == np.full((2, 3), 4)).all().all() assert (m.getVal(y) == np.full((2, 4), 3)).all().all() -@pytest.mark.parametrize("n", [50, 100, 200]) -def test_sum_performance(n): +@pytest.mark.parametrize( + "axis, keepdims", + [ + (0, False), + (0, True), + (1, False), + (1, True), + ((0, 2), False), + ((0, 2), True), + ], +) +def test_matrix_sum_result(axis, keepdims): + # directly compare the result of np.sum and MatrixExpr.sum + _getVal = np.vectorize(lambda e: e.terms[CONST]) + a = np.arange(6).reshape((1, 2, 3)) + + np_res = a.sum(axis, keepdims=keepdims) + scip_res = MatrixExpr.sum(a, axis, keepdims=keepdims) + assert (np_res == _getVal(scip_res)).all() + assert np_res.shape == _getVal(scip_res).shape + + +@pytest.mark.parametrize("n", [50, 100]) +def test_matrix_sum_axis_is_none_performance(n): model = Model() x = model.addMatrixVar((n, n)) @@ -229,6 +275,24 @@ def test_sum_performance(n): assert model.isGT(end_orig - start_orig, end_matrix - start_matrix) +@pytest.mark.parametrize("n", [50, 100]) +def test_matrix_sum_axis_not_none_performance(n): + model = Model() + x = model.addMatrixVar((n, n)) + + # Original sum via `np.ndarray.sum`, `np.sum` will call subclass method + start_orig = time() + np.ndarray.sum(x, axis=0) + end_orig = time() + + # Optimized sum via `quicksum` + start_matrix = time() + x.sum(axis=0) + end_matrix = time() + + assert model.isGT(end_orig - start_orig, end_matrix - start_matrix) + + def test_add_cons_matrixVar(): m = Model() matrix_variable = m.addMatrixVar(shape=(3, 3), vtype="B", name="A", obj=1) @@ -521,6 +585,14 @@ def test_matrix_matmul_return_type(): assert type(y @ z) is MatrixExpr +def test_matrix_sum_return_type(): + # test #1117, require returning type is MatrixExpr not MatrixVariable + m = Model() + + x = m.addMatrixVar((3, 2)) + assert type(x.sum(axis=1)) is MatrixExpr + + def test_broadcast(): # test #1065 m = Model() From 681e25f1306a993a131996fe7de2aa39c78ef7a2 Mon Sep 17 00:00:00 2001 From: Jonathan Berthias Date: Mon, 29 Dec 2025 15:14:39 +0100 Subject: [PATCH 03/15] Replace all *args and **kwargs with real parameters --- src/pyscipopt/scip.pyi | 1566 ++++++++++++++++++++-------------------- 1 file changed, 783 insertions(+), 783 deletions(-) diff --git a/src/pyscipopt/scip.pyi b/src/pyscipopt/scip.pyi index c89521f00..1c6cb298d 100644 --- a/src/pyscipopt/scip.pyi +++ b/src/pyscipopt/scip.pyi @@ -35,66 +35,66 @@ value_to_array: Incomplete class Benders: model: Incomplete name: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def benderscreatesub(self, *args, **kwargs): ... - def bendersexit(self, *args, **kwargs): ... - def bendersexitpre(self, *args, **kwargs): ... - def bendersexitsol(self, *args, **kwargs): ... - def bendersfree(self, *args, **kwargs): ... - def bendersfreesub(self, *args, **kwargs): ... - def bendersgetvar(self, *args, **kwargs): ... - def bendersinit(self, *args, **kwargs): ... - def bendersinitpre(self, *args, **kwargs): ... - def bendersinitsol(self, *args, **kwargs): ... - def benderspostsolve(self, *args, **kwargs): ... - def benderspresubsolve(self, *args, **kwargs): ... - def benderssolvesub(self, *args, **kwargs): ... - def benderssolvesubconvex(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def benderscreatesub(self, probnumber: Incomplete) -> Incomplete: ... + def bendersexit(self) -> Incomplete: ... + def bendersexitpre(self) -> Incomplete: ... + def bendersexitsol(self) -> Incomplete: ... + def bendersfree(self) -> Incomplete: ... + def bendersfreesub(self, probnumber: Incomplete) -> Incomplete: ... + def bendersgetvar(self, variable: Incomplete, probnumber: Incomplete) -> Incomplete: ... + def bendersinit(self) -> Incomplete: ... + def bendersinitpre(self) -> Incomplete: ... + def bendersinitsol(self) -> Incomplete: ... + def benderspostsolve(self, solution: Incomplete, enfotype: Incomplete, mergecandidates: Incomplete, npriomergecands: Incomplete, checkint: Incomplete, infeasible: Incomplete) -> Incomplete: ... + def benderspresubsolve(self, solution: Incomplete, enfotype: Incomplete, checkint: Incomplete) -> Incomplete: ... + def benderssolvesub(self, solution: Incomplete, probnumber: Incomplete) -> Incomplete: ... + def benderssolvesubconvex(self, solution: Incomplete, probnumber: Incomplete, onlyconvex: Incomplete) -> Incomplete: ... class Benderscut: benders: Incomplete model: Incomplete name: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def benderscutexec(self, *args, **kwargs): ... - def benderscutexit(self, *args, **kwargs): ... - def benderscutexitsol(self, *args, **kwargs): ... - def benderscutfree(self, *args, **kwargs): ... - def benderscutinit(self, *args, **kwargs): ... - def benderscutinitsol(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def benderscutexec(self, solution: Incomplete, probnumber: Incomplete, enfotype: Incomplete) -> Incomplete: ... + def benderscutexit(self) -> Incomplete: ... + def benderscutexitsol(self) -> Incomplete: ... + def benderscutfree(self) -> Incomplete: ... + def benderscutinit(self) -> Incomplete: ... + def benderscutinitsol(self) -> Incomplete: ... class BoundChange: - def __init__(self, *args, **kwargs) -> None: ... - def getBoundchgtype(self, *args, **kwargs): ... - def getBoundtype(self, *args, **kwargs): ... - def getNewBound(self, *args, **kwargs): ... - def getVar(self, *args, **kwargs): ... - def isRedundant(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def getBoundchgtype(self) -> Incomplete: ... + def getBoundtype(self) -> Incomplete: ... + def getNewBound(self) -> Incomplete: ... + def getVar(self) -> Incomplete: ... + def isRedundant(self) -> Incomplete: ... class Branchrule: model: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def branchexecext(self, *args, **kwargs): ... - def branchexeclp(self, *args, **kwargs): ... - def branchexecps(self, *args, **kwargs): ... - def branchexit(self, *args, **kwargs): ... - def branchexitsol(self, *args, **kwargs): ... - def branchfree(self, *args, **kwargs): ... - def branchinit(self, *args, **kwargs): ... - def branchinitsol(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def branchexecext(self, allowaddcons: Incomplete) -> Incomplete: ... + def branchexeclp(self, allowaddcons: Incomplete) -> Incomplete: ... + def branchexecps(self, allowaddcons: Incomplete) -> Incomplete: ... + def branchexit(self) -> Incomplete: ... + def branchexitsol(self) -> Incomplete: ... + def branchfree(self) -> Incomplete: ... + def branchinit(self) -> Incomplete: ... + def branchinitsol(self) -> Incomplete: ... class Column: data: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def getAge(self, *args, **kwargs): ... - def getBasisStatus(self, *args, **kwargs): ... - def getLPPos(self, *args, **kwargs): ... - def getLb(self, *args, **kwargs): ... - def getObjCoeff(self, *args, **kwargs): ... - def getPrimsol(self, *args, **kwargs): ... - def getUb(self, *args, **kwargs): ... - def getVar(self, *args, **kwargs): ... - def isIntegral(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def getAge(self) -> Incomplete: ... + def getBasisStatus(self) -> Incomplete: ... + def getLPPos(self) -> Incomplete: ... + def getLb(self) -> Incomplete: ... + def getObjCoeff(self) -> Incomplete: ... + def getPrimsol(self) -> Incomplete: ... + def getUb(self) -> Incomplete: ... + def getVar(self) -> Incomplete: ... + def isIntegral(self) -> Incomplete: ... def __eq__(self, other: object) -> bool: ... def __ge__(self, other: object) -> bool: ... def __gt__(self, other: object) -> bool: ... @@ -105,45 +105,45 @@ class Column: class ColumnExact: data: Incomplete - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class Conshdlr: model: Incomplete name: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def consactive(self, *args, **kwargs): ... - def conscheck(self, *args, **kwargs): ... - def conscopy(self, *args, **kwargs): ... - def consdeactive(self, *args, **kwargs): ... - def consdelete(self, *args, **kwargs): ... - def consdelvars(self, *args, **kwargs): ... - def consdisable(self, *args, **kwargs): ... - def consenable(self, *args, **kwargs): ... - def consenfolp(self, *args, **kwargs): ... - def consenfops(self, *args, **kwargs): ... - def consenforelax(self, *args, **kwargs): ... - def consexit(self, *args, **kwargs): ... - def consexitpre(self, *args, **kwargs): ... - def consexitsol(self, *args, **kwargs): ... - def consfree(self, *args, **kwargs): ... - def consgetdivebdchgs(self, *args, **kwargs): ... - def consgetnvars(self, *args, **kwargs): ... - def consgetpermsymgraph(self, *args, **kwargs): ... - def consgetsignedpermsymgraph(self, *args, **kwargs): ... - def consgetvars(self, *args, **kwargs): ... - def consinit(self, *args, **kwargs): ... - def consinitlp(self, *args, **kwargs): ... - def consinitpre(self, *args, **kwargs): ... - def consinitsol(self, *args, **kwargs): ... - def conslock(self, *args, **kwargs): ... - def consparse(self, *args, **kwargs): ... - def conspresol(self, *args, **kwargs): ... - def consprint(self, *args, **kwargs): ... - def consprop(self, *args, **kwargs): ... - def consresprop(self, *args, **kwargs): ... - def conssepalp(self, *args, **kwargs): ... - def conssepasol(self, *args, **kwargs): ... - def constrans(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def consactive(self, constraint: Incomplete) -> Incomplete: ... + def conscheck(self, constraints: Incomplete, solution: Incomplete, checkintegrality: Incomplete, checklprows: Incomplete, printreason: Incomplete, completely: Incomplete) -> Incomplete: ... + def conscopy(self) -> Incomplete: ... + def consdeactive(self, constraint: Incomplete) -> Incomplete: ... + def consdelete(self, constraint: Incomplete) -> Incomplete: ... + def consdelvars(self, constraints: Incomplete) -> Incomplete: ... + def consdisable(self, constraint: Incomplete) -> Incomplete: ... + def consenable(self, constraint: Incomplete) -> Incomplete: ... + def consenfolp(self, constraints: Incomplete, nusefulconss: Incomplete, solinfeasible: Incomplete) -> Incomplete: ... + def consenfops(self, constraints: Incomplete, nusefulconss: Incomplete, solinfeasible: Incomplete, objinfeasible: Incomplete) -> Incomplete: ... + def consenforelax(self, solution: Incomplete, constraints: Incomplete, nusefulconss: Incomplete, solinfeasible: Incomplete) -> Incomplete: ... + def consexit(self, constraints: Incomplete) -> Incomplete: ... + def consexitpre(self, constraints: Incomplete) -> Incomplete: ... + def consexitsol(self, constraints: Incomplete, restart: Incomplete) -> Incomplete: ... + def consfree(self) -> Incomplete: ... + def consgetdivebdchgs(self) -> Incomplete: ... + def consgetnvars(self, constraint: Incomplete) -> Incomplete: ... + def consgetpermsymgraph(self) -> Incomplete: ... + def consgetsignedpermsymgraph(self) -> Incomplete: ... + def consgetvars(self, constraint: Incomplete) -> Incomplete: ... + def consinit(self, constraints: Incomplete) -> Incomplete: ... + def consinitlp(self, constraints: Incomplete) -> Incomplete: ... + def consinitpre(self, constraints: Incomplete) -> Incomplete: ... + def consinitsol(self, constraints: Incomplete) -> Incomplete: ... + def conslock(self, constraint: Incomplete, locktype: Incomplete, nlockspos: Incomplete, nlocksneg: Incomplete) -> Incomplete: ... + def consparse(self) -> Incomplete: ... + def conspresol(self, constraints: Incomplete, nrounds: Incomplete, presoltiming: Incomplete, nnewfixedvars: Incomplete, nnewaggrvars: Incomplete, nnewchgvartypes: Incomplete, nnewchgbds: Incomplete, nnewholes: Incomplete, nnewdelconss: Incomplete, nnewaddconss: Incomplete, nnewupgdconss: Incomplete, nnewchgcoefs: Incomplete, nnewchgsides: Incomplete, result_dict: Incomplete) -> Incomplete: ... + def consprint(self, constraint: Incomplete) -> Incomplete: ... + def consprop(self, constraints: Incomplete, nusefulconss: Incomplete, nmarkedconss: Incomplete, proptiming: Incomplete) -> Incomplete: ... + def consresprop(self) -> Incomplete: ... + def conssepalp(self, constraints: Incomplete, nusefulconss: Incomplete) -> Incomplete: ... + def conssepasol(self, constraints: Incomplete, nusefulconss: Incomplete, solution: Incomplete) -> Incomplete: ... + def constrans(self, sourceconstraint: Incomplete) -> Incomplete: ... class Constant(GenExpr): number: Incomplete @@ -152,24 +152,24 @@ class Constant(GenExpr): class Constraint: data: Incomplete name: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def getConshdlrName(self, *args, **kwargs): ... - def isActive(self, *args, **kwargs): ... - def isChecked(self, *args, **kwargs): ... - def isDynamic(self, *args, **kwargs): ... - def isEnforced(self, *args, **kwargs): ... - def isInitial(self, *args, **kwargs): ... - def isKnapsack(self, *args, **kwargs): ... - def isLinear(self, *args, **kwargs): ... - def isLinearType(self, *args, **kwargs): ... - def isLocal(self, *args, **kwargs): ... - def isModifiable(self, *args, **kwargs): ... - def isNonlinear(self, *args, **kwargs): ... - def isOriginal(self, *args, **kwargs): ... - def isPropagated(self, *args, **kwargs): ... - def isRemovable(self, *args, **kwargs): ... - def isSeparated(self, *args, **kwargs): ... - def isStickingAtNode(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def getConshdlrName(self) -> Incomplete: ... + def isActive(self) -> Incomplete: ... + def isChecked(self) -> Incomplete: ... + def isDynamic(self) -> Incomplete: ... + def isEnforced(self) -> Incomplete: ... + def isInitial(self) -> Incomplete: ... + def isKnapsack(self) -> Incomplete: ... + def isLinear(self) -> Incomplete: ... + def isLinearType(self) -> Incomplete: ... + def isLocal(self) -> Incomplete: ... + def isModifiable(self) -> Incomplete: ... + def isNonlinear(self) -> Incomplete: ... + def isOriginal(self) -> Incomplete: ... + def isPropagated(self) -> Incomplete: ... + def isRemovable(self) -> Incomplete: ... + def isSeparated(self) -> Incomplete: ... + def isStickingAtNode(self) -> Incomplete: ... def __eq__(self, other: object) -> bool: ... def __ge__(self, other: object) -> bool: ... def __gt__(self, other: object) -> bool: ... @@ -180,29 +180,29 @@ class Constraint: class Cutsel: model: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def cutselexit(self, *args, **kwargs): ... - def cutselexitsol(self, *args, **kwargs): ... - def cutselfree(self, *args, **kwargs): ... - def cutselinit(self, *args, **kwargs): ... - def cutselinitsol(self, *args, **kwargs): ... - def cutselselect(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def cutselexit(self) -> Incomplete: ... + def cutselexitsol(self) -> Incomplete: ... + def cutselfree(self) -> Incomplete: ... + def cutselinit(self) -> Incomplete: ... + def cutselinitsol(self) -> Incomplete: ... + def cutselselect(self, cuts: Incomplete, forcedcuts: Incomplete, root: Incomplete, maxnselectedcuts: Incomplete) -> Incomplete: ... class DomainChanges: - def __init__(self, *args, **kwargs) -> None: ... - def getBoundchgs(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def getBoundchgs(self) -> Incomplete: ... class Event: data: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def _getEventNames(self, *args, **kwargs): ... - def getName(self, *args, **kwargs): ... - def getNewBound(self, *args, **kwargs): ... - def getNode(self, *args, **kwargs): ... - def getOldBound(self, *args, **kwargs): ... - def getRow(self, *args, **kwargs): ... - def getType(self, *args, **kwargs): ... - def getVar(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def _getEventNames(self) -> Incomplete: ... + def getName(self) -> Incomplete: ... + def getNewBound(self) -> Incomplete: ... + def getNode(self) -> Incomplete: ... + def getOldBound(self) -> Incomplete: ... + def getRow(self) -> Incomplete: ... + def getType(self) -> Incomplete: ... + def getVar(self) -> Incomplete: ... def __eq__(self, other: object) -> bool: ... def __ge__(self, other: object) -> bool: ... def __gt__(self, other: object) -> bool: ... @@ -214,21 +214,21 @@ class Event: class Eventhdlr: model: Incomplete name: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def eventcopy(self, *args, **kwargs): ... - def eventdelete(self, *args, **kwargs): ... - def eventexec(self, *args, **kwargs): ... - def eventexit(self, *args, **kwargs): ... - def eventexitsol(self, *args, **kwargs): ... - def eventfree(self, *args, **kwargs): ... - def eventinit(self, *args, **kwargs): ... - def eventinitsol(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def eventcopy(self) -> Incomplete: ... + def eventdelete(self) -> Incomplete: ... + def eventexec(self, event: Incomplete) -> Incomplete: ... + def eventexit(self) -> Incomplete: ... + def eventexitsol(self) -> Incomplete: ... + def eventfree(self) -> Incomplete: ... + def eventinit(self) -> Incomplete: ... + def eventinitsol(self) -> Incomplete: ... class Expr: terms: Incomplete def __init__(self, *args, **kwargs) -> None: ... - def degree(self, *args, **kwargs): ... - def normalize(self, *args, **kwargs): ... + def degree(self) -> Incomplete: ... + def normalize(self) -> Incomplete: ... def __abs__(self): ... def __add__(self, other): ... def __eq__(self, other: object) -> bool: ... @@ -243,7 +243,7 @@ class Expr: def __ne__(self, other: object) -> bool: ... def __neg__(self): ... def __next__(self): ... - def __pow__(self, other): ... + def __pow__(self, other: Incomplete, mod: Incomplete = ...) -> Incomplete: ... def __radd__(self, other): ... def __rmul__(self, other): ... def __rpow__(self, other): ... @@ -257,7 +257,7 @@ class ExprCons: _rhs: Incomplete expr: Incomplete def __init__(self, *args, **kwargs) -> None: ... - def normalize(self, *args, **kwargs): ... + def normalize(self) -> Incomplete: ... def __bool__(self) -> bool: ... def __eq__(self, other: object) -> bool: ... def __ge__(self, other: object) -> bool: ... @@ -270,8 +270,8 @@ class GenExpr: _op: Incomplete children: Incomplete def __init__(self, *args, **kwargs) -> None: ... - def degree(self, *args, **kwargs): ... - def getOp(self, *args, **kwargs): ... + def degree(self) -> Incomplete: ... + def getOp(self) -> Incomplete: ... def __abs__(self): ... def __add__(self, other): ... def __eq__(self, other: object) -> bool: ... @@ -282,7 +282,7 @@ class GenExpr: def __mul__(self, other): ... def __ne__(self, other: object) -> bool: ... def __neg__(self): ... - def __pow__(self, other): ... + def __pow__(self, other: Incomplete, mod: Incomplete = ...) -> Incomplete: ... def __radd__(self, other): ... def __rmul__(self, other): ... def __rpow__(self, other): ... @@ -294,86 +294,86 @@ class GenExpr: class Heur: model: Incomplete name: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def heurexec(self, *args, **kwargs): ... - def heurexit(self, *args, **kwargs): ... - def heurexitsol(self, *args, **kwargs): ... - def heurfree(self, *args, **kwargs): ... - def heurinit(self, *args, **kwargs): ... - def heurinitsol(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def heurexec(self, heurtiming: Incomplete, nodeinfeasible: Incomplete) -> Incomplete: ... + def heurexit(self) -> Incomplete: ... + def heurexitsol(self) -> Incomplete: ... + def heurfree(self) -> Incomplete: ... + def heurinit(self) -> Incomplete: ... + def heurinitsol(self) -> Incomplete: ... class IIS: - def __init__(self, *args, **kwargs) -> None: ... - def getNNodes(self, *args, **kwargs): ... - def getSubscip(self, *args, **kwargs): ... - def getTime(self, *args, **kwargs): ... - def greedyMakeIrreducible(self, *args, **kwargs): ... - def isSubscipInfeasible(self, *args, **kwargs): ... - def isSubscipIrreducible(self, *args, **kwargs): ... - def setSubscipInfeasible(self, *args, **kwargs): ... - def setSubscipIrreducible(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def getNNodes(self) -> Incomplete: ... + def getSubscip(self) -> Incomplete: ... + def getTime(self) -> Incomplete: ... + def greedyMakeIrreducible(self) -> Incomplete: ... + def isSubscipInfeasible(self) -> Incomplete: ... + def isSubscipIrreducible(self) -> Incomplete: ... + def setSubscipInfeasible(self, infeasible: Incomplete) -> Incomplete: ... + def setSubscipIrreducible(self, irreducible: Incomplete) -> Incomplete: ... class IISfinder: iis: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def iisfinderexec(self, *args, **kwargs): ... - def iisfinderfree(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def iisfinderexec(self) -> Incomplete: ... + def iisfinderfree(self) -> Incomplete: ... class LP: name: Incomplete def __init__(self, *args, **kwargs) -> None: ... - def addCol(self, *args, **kwargs): ... - def addCols(self, *args, **kwargs): ... - def addRow(self, *args, **kwargs): ... - def addRows(self, *args, **kwargs): ... - def chgBound(self, *args, **kwargs): ... - def chgCoef(self, *args, **kwargs): ... - def chgObj(self, *args, **kwargs): ... - def chgSide(self, *args, **kwargs): ... - def clear(self, *args, **kwargs): ... - def delCols(self, *args, **kwargs): ... - def delRows(self, *args, **kwargs): ... - def getActivity(self, *args, **kwargs): ... - def getBasisInds(self, *args, **kwargs): ... - def getBounds(self, *args, **kwargs): ... - def getDual(self, *args, **kwargs): ... - def getDualRay(self, *args, **kwargs): ... - def getIntParam(self, *args, **kwargs): ... - def getNIterations(self, *args, **kwargs): ... - def getObjVal(self, *args, **kwargs): ... - def getPrimal(self, *args, **kwargs): ... - def getPrimalRay(self, *args, **kwargs): ... - def getRealParam(self, *args, **kwargs): ... - def getRedcost(self, *args, **kwargs): ... - def getSides(self, *args, **kwargs): ... - def infinity(self, *args, **kwargs): ... - def isDualFeasible(self, *args, **kwargs): ... - def isInfinity(self, *args, **kwargs): ... - def isOptimal(self, *args, **kwargs): ... - def isPrimalFeasible(self, *args, **kwargs): ... - def ncols(self, *args, **kwargs): ... - def nrows(self, *args, **kwargs): ... - def readLP(self, *args, **kwargs): ... - def setIntParam(self, *args, **kwargs): ... - def setRealParam(self, *args, **kwargs): ... - def solve(self, *args, **kwargs): ... - def writeLP(self, *args, **kwargs): ... + def addCol(self, entries: Incomplete, obj: Incomplete = ..., lb: Incomplete = ..., ub: Incomplete = ...) -> Incomplete: ... + def addCols(self, entrieslist: Incomplete, objs: Incomplete = ..., lbs: Incomplete = ..., ubs: Incomplete = ...) -> Incomplete: ... + def addRow(self, entries: Incomplete, lhs: Incomplete = ..., rhs: Incomplete = ...) -> Incomplete: ... + def addRows(self, entrieslist: Incomplete, lhss: Incomplete = ..., rhss: Incomplete = ...) -> Incomplete: ... + def chgBound(self, col: Incomplete, lb: Incomplete, ub: Incomplete) -> Incomplete: ... + def chgCoef(self, row: Incomplete, col: Incomplete, newval: Incomplete) -> Incomplete: ... + def chgObj(self, col: Incomplete, obj: Incomplete) -> Incomplete: ... + def chgSide(self, row: Incomplete, lhs: Incomplete, rhs: Incomplete) -> Incomplete: ... + def clear(self) -> Incomplete: ... + def delCols(self, firstcol: Incomplete, lastcol: Incomplete) -> Incomplete: ... + def delRows(self, firstrow: Incomplete, lastrow: Incomplete) -> Incomplete: ... + def getActivity(self) -> Incomplete: ... + def getBasisInds(self) -> Incomplete: ... + def getBounds(self, firstcol: Incomplete = ..., lastcol: Incomplete = ...) -> Incomplete: ... + def getDual(self) -> Incomplete: ... + def getDualRay(self) -> Incomplete: ... + def getIntParam(self, param: Incomplete) -> Incomplete: ... + def getNIterations(self) -> Incomplete: ... + def getObjVal(self) -> Incomplete: ... + def getPrimal(self) -> Incomplete: ... + def getPrimalRay(self) -> Incomplete: ... + def getRealParam(self, param: Incomplete) -> Incomplete: ... + def getRedcost(self) -> Incomplete: ... + def getSides(self, firstrow: Incomplete = ..., lastrow: Incomplete = ...) -> Incomplete: ... + def infinity(self) -> Incomplete: ... + def isDualFeasible(self) -> Incomplete: ... + def isInfinity(self, val: Incomplete) -> Incomplete: ... + def isOptimal(self) -> Incomplete: ... + def isPrimalFeasible(self) -> Incomplete: ... + def ncols(self) -> Incomplete: ... + def nrows(self) -> Incomplete: ... + def readLP(self, filename: Incomplete) -> Incomplete: ... + def setIntParam(self, param: Incomplete, value: Incomplete) -> Incomplete: ... + def setRealParam(self, param: Incomplete, value: Incomplete) -> Incomplete: ... + def solve(self, dual: Incomplete = ...) -> Incomplete: ... + def writeLP(self, filename: Incomplete) -> Incomplete: ... class MatrixConstraint(numpy.ndarray): - def getConshdlrName(self, *args, **kwargs): ... - def isActive(self, *args, **kwargs): ... - def isChecked(self, *args, **kwargs): ... - def isDynamic(self, *args, **kwargs): ... - def isEnforced(self, *args, **kwargs): ... - def isInitial(self, *args, **kwargs): ... - def isLinear(self, *args, **kwargs): ... - def isLocal(self, *args, **kwargs): ... - def isModifiable(self, *args, **kwargs): ... - def isNonlinear(self, *args, **kwargs): ... - def isPropagated(self, *args, **kwargs): ... - def isRemovable(self, *args, **kwargs): ... - def isSeparated(self, *args, **kwargs): ... - def isStickingAtNode(self, *args, **kwargs): ... + def getConshdlrName(self) -> Incomplete: ... + def isActive(self) -> Incomplete: ... + def isChecked(self) -> Incomplete: ... + def isDynamic(self) -> Incomplete: ... + def isEnforced(self) -> Incomplete: ... + def isInitial(self) -> Incomplete: ... + def isLinear(self) -> Incomplete: ... + def isLocal(self) -> Incomplete: ... + def isModifiable(self) -> Incomplete: ... + def isNonlinear(self) -> Incomplete: ... + def isPropagated(self) -> Incomplete: ... + def isRemovable(self) -> Incomplete: ... + def isSeparated(self) -> Incomplete: ... + def isStickingAtNode(self) -> Incomplete: ... class MatrixExpr(numpy.ndarray): def sum(self, *args, **kwargs): ... @@ -382,7 +382,7 @@ class MatrixExpr(numpy.ndarray): def __ge__(self, other: object) -> MatrixExprCons: ... def __iadd__(self, other): ... def __le__(self, other: object) -> MatrixExprCons: ... - def __matmul__(self, *args, **kwargs): ... + def __matmul__(self, other: Incomplete) -> Incomplete: ... def __mul__(self, other): ... def __pow__(self, other): ... def __radd__(self, other): ... @@ -400,439 +400,439 @@ class MatrixExprCons(numpy.ndarray): class MatrixGenExpr(MatrixExpr): ... class MatrixVariable(MatrixExpr): - def getAvgSol(self, *args, **kwargs): ... - def getCol(self, *args, **kwargs): ... - def getIndex(self, *args, **kwargs): ... - def getLPSol(self, *args, **kwargs): ... - def getLbGlobal(self, *args, **kwargs): ... - def getLbLocal(self, *args, **kwargs): ... - def getLbOriginal(self, *args, **kwargs): ... - def getObj(self, *args, **kwargs): ... - def getUbGlobal(self, *args, **kwargs): ... - def getUbLocal(self, *args, **kwargs): ... - def getUbOriginal(self, *args, **kwargs): ... - def isInLP(self, *args, **kwargs): ... - def varMayRound(self, *args, **kwargs): ... - def vtype(self, *args, **kwargs): ... + def getAvgSol(self) -> Incomplete: ... + def getCol(self) -> Incomplete: ... + def getIndex(self) -> Incomplete: ... + def getLPSol(self) -> Incomplete: ... + def getLbGlobal(self) -> Incomplete: ... + def getLbLocal(self) -> Incomplete: ... + def getLbOriginal(self) -> Incomplete: ... + def getObj(self) -> Incomplete: ... + def getUbGlobal(self) -> Incomplete: ... + def getUbLocal(self) -> Incomplete: ... + def getUbOriginal(self) -> Incomplete: ... + def isInLP(self) -> Incomplete: ... + def varMayRound(self, direction: Incomplete = ...) -> Incomplete: ... + def vtype(self) -> Incomplete: ... class Model: _freescip: Incomplete data: Incomplete def __init__(self, *args, **kwargs) -> None: ... - def _createConsGenNonlinear(self, *args, **kwargs): ... - def _createConsLinear(self, *args, **kwargs): ... - def _createConsNonlinear(self, *args, **kwargs): ... - def _createConsQuadratic(self, *args, **kwargs): ... - def _getStageNames(self, *args, **kwargs): ... - def activateBenders(self, *args, **kwargs): ... - def addBendersSubproblem(self, *args, **kwargs): ... - def addCoefKnapsack(self, *args, **kwargs): ... - def addCoefLinear(self, *args, **kwargs): ... - def addCons(self, *args, **kwargs): ... - def addConsAnd(self, *args, **kwargs): ... - def addConsCardinality(self, *args, **kwargs): ... - def addConsCoeff(self, *args, **kwargs): ... - def addConsDisjunction(self, *args, **kwargs): ... - def addConsElemDisjunction(self, *args, **kwargs): ... - def addConsIndicator(self, *args, **kwargs): ... - def addConsKnapsack(self, *args, **kwargs): ... - def addConsLocal(self, *args, **kwargs): ... - def addConsNode(self, *args, **kwargs): ... - def addConsOr(self, *args, **kwargs): ... - def addConsSOS1(self, *args, **kwargs): ... - def addConsSOS2(self, *args, **kwargs): ... - def addConsXor(self, *args, **kwargs): ... - def addConss(self, *args, **kwargs): ... - def addCut(self, *args, **kwargs): ... - def addExprNonlinear(self, *args, **kwargs): ... - def addMatrixCons(self, *args, **kwargs): ... - def addMatrixConsIndicator(self, *args, **kwargs): ... - def addMatrixVar(self, *args, **kwargs): ... - def addObjoffset(self, *args, **kwargs): ... - def addPoolCut(self, *args, **kwargs): ... - def addPyCons(self, *args, **kwargs): ... - def addRowDive(self, *args, **kwargs): ... - def addRowExact(self, *args, **kwargs): ... - def addSol(self, *args, **kwargs): ... - def addVar(self, *args, **kwargs): ... - def addVarLocks(self, *args, **kwargs): ... - def addVarLocksType(self, *args, **kwargs): ... - def addVarSOS1(self, *args, **kwargs): ... - def addVarSOS2(self, *args, **kwargs): ... - def addVarToRow(self, *args, **kwargs): ... - def allColsInLP(self, *args, **kwargs): ... - def allowNegSlackExact(self, *args, **kwargs): ... - def appendVarSOS1(self, *args, **kwargs): ... - def appendVarSOS2(self, *args, **kwargs): ... - def applyCutsProbing(self, *args, **kwargs): ... - def attachEventHandlerCallback(self, *args, **kwargs): ... - def backtrackProbing(self, *args, **kwargs): ... - def branchLPExact(self, *args, **kwargs): ... - def branchVar(self, *args, **kwargs): ... - def branchVarVal(self, *args, **kwargs): ... - def cacheRowExtensions(self, *args, **kwargs): ... - def calcChildEstimate(self, *args, **kwargs): ... - def calcNodeselPriority(self, *args, **kwargs): ... - def catchEvent(self, *args, **kwargs): ... - def catchRowEvent(self, *args, **kwargs): ... - def catchVarEvent(self, *args, **kwargs): ... - def checkBendersSubproblemOptimality(self, *args, **kwargs): ... - def checkQuadraticNonlinear(self, *args, **kwargs): ... - def checkSol(self, *args, **kwargs): ... - def chgCapacityKnapsack(self, *args, **kwargs): ... - def chgCoefLinear(self, *args, **kwargs): ... - def chgLhs(self, *args, **kwargs): ... - def chgReoptObjective(self, *args, **kwargs): ... - def chgRhs(self, *args, **kwargs): ... - def chgRowLhsDive(self, *args, **kwargs): ... - def chgRowRhsDive(self, *args, **kwargs): ... - def chgVarBranchPriority(self, *args, **kwargs): ... - def chgVarLb(self, *args, **kwargs): ... - def chgVarLbDive(self, *args, **kwargs): ... - def chgVarLbGlobal(self, *args, **kwargs): ... - def chgVarLbNode(self, *args, **kwargs): ... - def chgVarLbProbing(self, *args, **kwargs): ... - def chgVarObjDive(self, *args, **kwargs): ... - def chgVarObjProbing(self, *args, **kwargs): ... - def chgVarType(self, *args, **kwargs): ... - def chgVarUb(self, *args, **kwargs): ... - def chgVarUbDive(self, *args, **kwargs): ... - def chgVarUbGlobal(self, *args, **kwargs): ... - def chgVarUbNode(self, *args, **kwargs): ... - def chgVarUbProbing(self, *args, **kwargs): ... - def computeBestSolSubproblems(self, *args, **kwargs): ... - def constructLP(self, *args, **kwargs): ... - def copyLargeNeighborhoodSearch(self, *args, **kwargs): ... - def count(self, *args, **kwargs): ... - def createChild(self, *args, **kwargs): ... - def createCons(self, *args, **kwargs): ... - def createConsFromExpr(self, *args, **kwargs): ... - def createEmptyRowSepa(self, *args, **kwargs): ... - def createEmptyRowUnspec(self, *args, **kwargs): ... - def createOrigSol(self, *args, **kwargs): ... - def createPartialSol(self, *args, **kwargs): ... - def createProbBasic(self, *args, **kwargs): ... - def createSol(self, *args, **kwargs): ... - def cutoffNode(self, *args, **kwargs): ... - def deactivatePricer(self, *args, **kwargs): ... - def delCoefLinear(self, *args, **kwargs): ... - def delCons(self, *args, **kwargs): ... - def delConsLocal(self, *args, **kwargs): ... - def delVar(self, *args, **kwargs): ... - def disableDebugSol(self, *args, **kwargs): ... - def disablePropagation(self, *args, **kwargs): ... - def dropEvent(self, *args, **kwargs): ... - def dropRowEvent(self, *args, **kwargs): ... - def dropVarEvent(self, *args, **kwargs): ... - def enableDebugSol(self, *args, **kwargs): ... - def enableExactSolving(self, *args, **kwargs): ... - def enableReoptimization(self, *args, **kwargs): ... - def endDive(self, *args, **kwargs): ... - def endProbing(self, *args, **kwargs): ... - def endStrongbranch(self, *args, **kwargs): ... - def epsilon(self, *args, **kwargs): ... - def feasCeil(self, *args, **kwargs): ... - def feasFloor(self, *args, **kwargs): ... - def feasFrac(self, *args, **kwargs): ... - def feasRound(self, *args, **kwargs): ... - def feastol(self, *args, **kwargs): ... - def fixVar(self, *args, **kwargs): ... - def fixVarProbing(self, *args, **kwargs): ... - def flushRowExtensions(self, *args, **kwargs): ... - def frac(self, *args, **kwargs): ... - def freeBendersSubproblems(self, *args, **kwargs): ... - def freeProb(self, *args, **kwargs): ... - def freeReoptSolve(self, *args, **kwargs): ... - def freeSol(self, *args, **kwargs): ... - def freeTransform(self, *args, **kwargs): ... + def _createConsGenNonlinear(self, cons: Incomplete, **kwargs: Incomplete) -> Incomplete: ... + def _createConsLinear(self, lincons: Incomplete, **kwargs: Incomplete) -> Incomplete: ... + def _createConsNonlinear(self, cons: Incomplete, **kwargs: Incomplete) -> Incomplete: ... + def _createConsQuadratic(self, quadcons: Incomplete, **kwargs: Incomplete) -> Incomplete: ... + def _getStageNames(self) -> Incomplete: ... + def activateBenders(self, benders: Incomplete, nsubproblems: Incomplete) -> Incomplete: ... + def addBendersSubproblem(self, benders: Incomplete, subproblem: Incomplete) -> Incomplete: ... + def addCoefKnapsack(self, cons: Incomplete, var: Incomplete, weight: Incomplete) -> Incomplete: ... + def addCoefLinear(self, cons: Incomplete, var: Incomplete, value: Incomplete) -> Incomplete: ... + def addCons(self, cons: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... + def addConsAnd(self, vars: Incomplete, resvar: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... + def addConsCardinality(self, consvars: Incomplete, cardval: Incomplete, indvars: Incomplete = ..., weights: Incomplete = ..., name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... + def addConsCoeff(self, cons: Incomplete, var: Incomplete, coeff: Incomplete) -> Incomplete: ... + def addConsDisjunction(self, conss: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., relaxcons: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ...) -> Incomplete: ... + def addConsElemDisjunction(self, disj_cons: Incomplete, cons: Incomplete) -> Incomplete: ... + def addConsIndicator(self, cons: Incomplete, binvar: Incomplete = ..., activeone: Incomplete = ..., name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... + def addConsKnapsack(self, vars: Incomplete, weights: Incomplete, capacity: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., modifiable: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... + def addConsLocal(self, cons: Incomplete, validnode: Incomplete = ...) -> Incomplete: ... + def addConsNode(self, node: Incomplete, cons: Incomplete, validnode: Incomplete = ...) -> Incomplete: ... + def addConsOr(self, vars: Incomplete, resvar: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... + def addConsSOS1(self, vars: Incomplete, weights: Incomplete = ..., name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... + def addConsSOS2(self, vars: Incomplete, weights: Incomplete = ..., name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... + def addConsXor(self, vars: Incomplete, rhsvar: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... + def addConss(self, conss: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... + def addCut(self, cut: Incomplete, forcecut: Incomplete = ...) -> Incomplete: ... + def addExprNonlinear(self, cons: Incomplete, expr: Incomplete, coef: Incomplete) -> Incomplete: ... + def addMatrixCons(self, cons: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... + def addMatrixConsIndicator(self, cons: Incomplete, binvar: Incomplete = ..., activeone: Incomplete = ..., name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... + def addMatrixVar(self, shape: Incomplete, name: Incomplete = ..., vtype: Incomplete = ..., lb: Incomplete = ..., ub: Incomplete = ..., obj: Incomplete = ..., pricedVar: Incomplete = ..., pricedVarScore: Incomplete = ...) -> Incomplete: ... + def addObjoffset(self, offset: Incomplete, solutions: Incomplete = ...) -> Incomplete: ... + def addPoolCut(self, row: Incomplete) -> Incomplete: ... + def addPyCons(self, cons: Incomplete) -> Incomplete: ... + def addRowDive(self, row: Incomplete) -> Incomplete: ... + def addRowExact(self, rowexact: Incomplete) -> Incomplete: ... + def addSol(self, solution: Incomplete, free: Incomplete = ...) -> Incomplete: ... + def addVar(self, name: Incomplete = ..., vtype: Incomplete = ..., lb: Incomplete = ..., ub: Incomplete = ..., obj: Incomplete = ..., pricedVar: Incomplete = ..., pricedVarScore: Incomplete = ..., deletable: Incomplete = ...) -> Incomplete: ... + def addVarLocks(self, var: Incomplete, nlocksdown: Incomplete, nlocksup: Incomplete) -> Incomplete: ... + def addVarLocksType(self, var: Incomplete, locktype: Incomplete, nlocksdown: Incomplete, nlocksup: Incomplete) -> Incomplete: ... + def addVarSOS1(self, cons: Incomplete, var: Incomplete, weight: Incomplete) -> Incomplete: ... + def addVarSOS2(self, cons: Incomplete, var: Incomplete, weight: Incomplete) -> Incomplete: ... + def addVarToRow(self, row: Incomplete, var: Incomplete, value: Incomplete) -> Incomplete: ... + def allColsInLP(self) -> Incomplete: ... + def allowNegSlackExact(self) -> Incomplete: ... + def appendVarSOS1(self, cons: Incomplete, var: Incomplete) -> Incomplete: ... + def appendVarSOS2(self, cons: Incomplete, var: Incomplete) -> Incomplete: ... + def applyCutsProbing(self) -> Incomplete: ... + def attachEventHandlerCallback(self, callback: Incomplete, events: Incomplete, name: Incomplete = ..., description: Incomplete = ...) -> Incomplete: ... + def backtrackProbing(self, probingdepth: Incomplete) -> Incomplete: ... + def branchLPExact(self) -> Incomplete: ... + def branchVar(self, variable: Incomplete) -> Incomplete: ... + def branchVarVal(self, variable: Incomplete, value: Incomplete) -> Incomplete: ... + def cacheRowExtensions(self, row: Incomplete) -> Incomplete: ... + def calcChildEstimate(self, variable: Incomplete, targetvalue: Incomplete) -> Incomplete: ... + def calcNodeselPriority(self, variable: Incomplete, branchdir: Incomplete, targetvalue: Incomplete) -> Incomplete: ... + def catchEvent(self, eventtype: Incomplete, eventhdlr: Incomplete) -> Incomplete: ... + def catchRowEvent(self, row: Incomplete, eventtype: Incomplete, eventhdlr: Incomplete) -> Incomplete: ... + def catchVarEvent(self, var: Incomplete, eventtype: Incomplete, eventhdlr: Incomplete) -> Incomplete: ... + def checkBendersSubproblemOptimality(self, solution: Incomplete, probnumber: Incomplete, benders: Incomplete = ...) -> Incomplete: ... + def checkQuadraticNonlinear(self, cons: Incomplete) -> Incomplete: ... + def checkSol(self, solution: Incomplete, printreason: Incomplete = ..., completely: Incomplete = ..., checkbounds: Incomplete = ..., checkintegrality: Incomplete = ..., checklprows: Incomplete = ..., original: Incomplete = ...) -> Incomplete: ... + def chgCapacityKnapsack(self, cons: Incomplete, capacity: Incomplete) -> Incomplete: ... + def chgCoefLinear(self, cons: Incomplete, var: Incomplete, value: Incomplete) -> Incomplete: ... + def chgLhs(self, cons: Incomplete, lhs: Incomplete) -> Incomplete: ... + def chgReoptObjective(self, coeffs: Incomplete, sense: Incomplete = ...) -> Incomplete: ... + def chgRhs(self, cons: Incomplete, rhs: Incomplete) -> Incomplete: ... + def chgRowLhsDive(self, row: Incomplete, newlhs: Incomplete) -> Incomplete: ... + def chgRowRhsDive(self, row: Incomplete, newrhs: Incomplete) -> Incomplete: ... + def chgVarBranchPriority(self, var: Incomplete, priority: Incomplete) -> Incomplete: ... + def chgVarLb(self, var: Incomplete, lb: Incomplete) -> Incomplete: ... + def chgVarLbDive(self, var: Incomplete, newbound: Incomplete) -> Incomplete: ... + def chgVarLbGlobal(self, var: Incomplete, lb: Incomplete) -> Incomplete: ... + def chgVarLbNode(self, node: Incomplete, var: Incomplete, lb: Incomplete) -> Incomplete: ... + def chgVarLbProbing(self, var: Incomplete, lb: Incomplete) -> Incomplete: ... + def chgVarObjDive(self, var: Incomplete, newobj: Incomplete) -> Incomplete: ... + def chgVarObjProbing(self, var: Incomplete, newobj: Incomplete) -> Incomplete: ... + def chgVarType(self, var: Incomplete, vtype: Incomplete) -> Incomplete: ... + def chgVarUb(self, var: Incomplete, ub: Incomplete) -> Incomplete: ... + def chgVarUbDive(self, var: Incomplete, newbound: Incomplete) -> Incomplete: ... + def chgVarUbGlobal(self, var: Incomplete, ub: Incomplete) -> Incomplete: ... + def chgVarUbNode(self, node: Incomplete, var: Incomplete, ub: Incomplete) -> Incomplete: ... + def chgVarUbProbing(self, var: Incomplete, ub: Incomplete) -> Incomplete: ... + def computeBestSolSubproblems(self) -> Incomplete: ... + def constructLP(self) -> Incomplete: ... + def copyLargeNeighborhoodSearch(self, to_fix: Incomplete, fix_vals: Incomplete) -> Incomplete: ... + def count(self) -> Incomplete: ... + def createChild(self, nodeselprio: Incomplete, estimate: Incomplete) -> Incomplete: ... + def createCons(self, conshdlr: Incomplete, name: Incomplete, initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... + def createConsFromExpr(self, cons: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... + def createEmptyRowSepa(self, sepa: Incomplete, name: Incomplete = ..., lhs: Incomplete = ..., rhs: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., removable: Incomplete = ...) -> Incomplete: ... + def createEmptyRowUnspec(self, name: Incomplete = ..., lhs: Incomplete = ..., rhs: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., removable: Incomplete = ...) -> Incomplete: ... + def createOrigSol(self, heur: Incomplete = ...) -> Incomplete: ... + def createPartialSol(self, heur: Incomplete = ...) -> Incomplete: ... + def createProbBasic(self, problemName: Incomplete = ...) -> Incomplete: ... + def createSol(self, heur: Incomplete = ..., initlp: Incomplete = ...) -> Incomplete: ... + def cutoffNode(self, node: Incomplete) -> Incomplete: ... + def deactivatePricer(self, pricer: Incomplete) -> Incomplete: ... + def delCoefLinear(self, cons: Incomplete, var: Incomplete) -> Incomplete: ... + def delCons(self, cons: Incomplete) -> Incomplete: ... + def delConsLocal(self, cons: Incomplete) -> Incomplete: ... + def delVar(self, var: Incomplete) -> Incomplete: ... + def disableDebugSol(self) -> Incomplete: ... + def disablePropagation(self, onlyroot: Incomplete = ...) -> Incomplete: ... + def dropEvent(self, eventtype: Incomplete, eventhdlr: Incomplete) -> Incomplete: ... + def dropRowEvent(self, row: Incomplete, eventtype: Incomplete, eventhdlr: Incomplete) -> Incomplete: ... + def dropVarEvent(self, var: Incomplete, eventtype: Incomplete, eventhdlr: Incomplete) -> Incomplete: ... + def enableDebugSol(self) -> Incomplete: ... + def enableExactSolving(self, enable: Incomplete) -> Incomplete: ... + def enableReoptimization(self, enable: Incomplete = ...) -> Incomplete: ... + def endDive(self) -> Incomplete: ... + def endProbing(self) -> Incomplete: ... + def endStrongbranch(self) -> Incomplete: ... + def epsilon(self) -> Incomplete: ... + def feasCeil(self, value: Incomplete) -> Incomplete: ... + def feasFloor(self, value: Incomplete) -> Incomplete: ... + def feasFrac(self, value: Incomplete) -> Incomplete: ... + def feasRound(self, value: Incomplete) -> Incomplete: ... + def feastol(self) -> Incomplete: ... + def fixVar(self, var: Incomplete, val: Incomplete) -> Incomplete: ... + def fixVarProbing(self, var: Incomplete, fixedval: Incomplete) -> Incomplete: ... + def flushRowExtensions(self, row: Incomplete) -> Incomplete: ... + def frac(self, value: Incomplete) -> Incomplete: ... + def freeBendersSubproblems(self) -> Incomplete: ... + def freeProb(self) -> Incomplete: ... + def freeReoptSolve(self) -> Incomplete: ... + def freeSol(self, solution: Incomplete) -> Incomplete: ... + def freeTransform(self) -> Incomplete: ... @staticmethod - def from_ptr(*args, **kwargs): ... - def generateIIS(self, *args, **kwargs): ... - def getActivity(self, *args, **kwargs): ... - def getBendersAuxiliaryVar(self, *args, **kwargs): ... - def getBendersSubproblem(self, *args, **kwargs): ... - def getBendersVar(self, *args, **kwargs): ... - def getBestChild(self, *args, **kwargs): ... - def getBestLeaf(self, *args, **kwargs): ... - def getBestNode(self, *args, **kwargs): ... - def getBestSibling(self, *args, **kwargs): ... - def getBestSol(self, *args, **kwargs): ... - def getBestboundNode(self, *args, **kwargs): ... - def getBipartiteGraphRepresentation(self, *args, **kwargs): ... - def getBranchScoreMultiple(self, *args, **kwargs): ... - def getCapacityKnapsack(self, *args, **kwargs): ... - def getChildren(self, *args, **kwargs): ... - def getColRedCost(self, *args, **kwargs): ... - def getCondition(self, *args, **kwargs): ... - def getConsNVars(self, *args, **kwargs): ... - def getConsVals(self, *args, **kwargs): ... - def getConsVars(self, *args, **kwargs): ... - def getConss(self, *args, **kwargs): ... - def getCurrentNode(self, *args, **kwargs): ... - def getCutEfficacy(self, *args, **kwargs): ... - def getCutLPSolCutoffDistance(self, *args, **kwargs): ... - def getCutoffbound(self, *args, **kwargs): ... - def getDepth(self, *args, **kwargs): ... - def getDualMultiplier(self, *args, **kwargs): ... - def getDualSolVal(self, *args, **kwargs): ... - def getDualbound(self, *args, **kwargs): ... - def getDualboundRoot(self, *args, **kwargs): ... - def getDualfarkasKnapsack(self, *args, **kwargs): ... - def getDualfarkasLinear(self, *args, **kwargs): ... - def getDualsolKnapsack(self, *args, **kwargs): ... - def getDualsolLinear(self, *args, **kwargs): ... - def getGap(self, *args, **kwargs): ... - def getHeurTiming(self, *args, **kwargs): ... - def getIIS(self, *args, **kwargs): ... - def getLPBInvARow(self, *args, **kwargs): ... - def getLPBInvRow(self, *args, **kwargs): ... - def getLPBasisInd(self, *args, **kwargs): ... - def getLPBranchCands(self, *args, **kwargs): ... - def getLPColsData(self, *args, **kwargs): ... - def getLPObjVal(self, *args, **kwargs): ... - def getLPRowsData(self, *args, **kwargs): ... - def getLPSolstat(self, *args, **kwargs): ... - def getLeaves(self, *args, **kwargs): ... - def getLhs(self, *args, **kwargs): ... - def getLinearConsIndicator(self, *args, **kwargs): ... - def getLocalEstimate(self, *args, **kwargs): ... - def getLowerbound(self, *args, **kwargs): ... - def getMajorVersion(self, *args, **kwargs): ... - def getMaxDepth(self, *args, **kwargs): ... - def getMinorVersion(self, *args, **kwargs): ... - def getNBestSolsFound(self, *args, **kwargs): ... - def getNBinVars(self, *args, **kwargs): ... - def getNChildren(self, *args, **kwargs): ... - def getNConss(self, *args, **kwargs): ... - def getNContVars(self, *args, **kwargs): ... - def getNCountedSols(self, *args, **kwargs): ... - def getNCuts(self, *args, **kwargs): ... - def getNCutsApplied(self, *args, **kwargs): ... - def getNFeasibleLeaves(self, *args, **kwargs): ... - def getNImplVars(self, *args, **kwargs): ... - def getNInfeasibleLeaves(self, *args, **kwargs): ... - def getNIntVars(self, *args, **kwargs): ... - def getNLPBranchCands(self, *args, **kwargs): ... - def getNLPCols(self, *args, **kwargs): ... - def getNLPIterations(self, *args, **kwargs): ... - def getNLPRows(self, *args, **kwargs): ... - def getNLPs(self, *args, **kwargs): ... - def getNLeaves(self, *args, **kwargs): ... - def getNLimSolsFound(self, *args, **kwargs): ... - def getNNlRows(self, *args, **kwargs): ... - def getNNodeLPIterations(self, *args, **kwargs): ... - def getNNodes(self, *args, **kwargs): ... - def getNReaders(self, *args, **kwargs): ... - def getNSepaRounds(self, *args, **kwargs): ... - def getNSiblings(self, *args, **kwargs): ... - def getNSols(self, *args, **kwargs): ... - def getNSolsFound(self, *args, **kwargs): ... - def getNStrongbranchLPIterations(self, *args, **kwargs): ... - def getNTotalNodes(self, *args, **kwargs): ... - def getNVars(self, *args, **kwargs): ... - def getNVarsAnd(self, *args, **kwargs): ... - def getNlRowActivityBounds(self, *args, **kwargs): ... - def getNlRowSolActivity(self, *args, **kwargs): ... - def getNlRowSolFeasibility(self, *args, **kwargs): ... - def getNlRows(self, *args, **kwargs): ... - def getObjVal(self, *args, **kwargs): ... - def getObjective(self, *args, **kwargs): ... - def getObjectiveSense(self, *args, **kwargs): ... - def getObjlimit(self, *args, **kwargs): ... - def getObjoffset(self, *args, **kwargs): ... - def getOpenNodes(self, *args, **kwargs): ... - def getParam(self, *args, **kwargs): ... - def getParams(self, *args, **kwargs): ... - def getPlungeDepth(self, *args, **kwargs): ... - def getPresolvingTime(self, *args, **kwargs): ... - def getPrimalRay(self, *args, **kwargs): ... - def getPrimalRayVal(self, *args, **kwargs): ... - def getPrimalbound(self, *args, **kwargs): ... - def getPrioChild(self, *args, **kwargs): ... - def getPrioSibling(self, *args, **kwargs): ... - def getProbName(self, *args, **kwargs): ... - def getProbingDepth(self, *args, **kwargs): ... - def getPseudoBranchCands(self, *args, **kwargs): ... - def getReadingTime(self, *args, **kwargs): ... - def getResultantAnd(self, *args, **kwargs): ... - def getRhs(self, *args, **kwargs): ... - def getRowActivity(self, *args, **kwargs): ... - def getRowDualSol(self, *args, **kwargs): ... - def getRowLPActivity(self, *args, **kwargs): ... - def getRowLinear(self, *args, **kwargs): ... - def getRowNumIntCols(self, *args, **kwargs): ... - def getRowObjParallelism(self, *args, **kwargs): ... - def getRowParallelism(self, *args, **kwargs): ... - def getSiblings(self, *args, **kwargs): ... - def getSlack(self, *args, **kwargs): ... - def getSlackVarIndicator(self, *args, **kwargs): ... - def getSolObjVal(self, *args, **kwargs): ... - def getSolTime(self, *args, **kwargs): ... - def getSolVal(self, *args, **kwargs): ... - def getSols(self, *args, **kwargs): ... - def getSolvingTime(self, *args, **kwargs): ... - def getStage(self, *args, **kwargs): ... - def getStageName(self, *args, **kwargs): ... - def getStatus(self, *args, **kwargs): ... - def getTechVersion(self, *args, **kwargs): ... - def getTermsQuadratic(self, *args, **kwargs): ... - def getTotalTime(self, *args, **kwargs): ... - def getTransformedCons(self, *args, **kwargs): ... - def getTransformedVar(self, *args, **kwargs): ... - def getTreesizeEstimation(self, *args, **kwargs): ... - def getVal(self, *args, **kwargs): ... - def getValsLinear(self, *args, **kwargs): ... - def getVarDict(self, *args, **kwargs): ... - def getVarLbDive(self, *args, **kwargs): ... - def getVarPseudocost(self, *args, **kwargs): ... - def getVarPseudocostScore(self, *args, **kwargs): ... - def getVarRedcost(self, *args, **kwargs): ... - def getVarStrongbranch(self, *args, **kwargs): ... - def getVarStrongbranchLast(self, *args, **kwargs): ... - def getVarStrongbranchNode(self, *args, **kwargs): ... - def getVarUbDive(self, *args, **kwargs): ... - def getVars(self, *args, **kwargs): ... - def getVarsAnd(self, *args, **kwargs): ... - def getWeightsKnapsack(self, *args, **kwargs): ... - def hasPrimalRay(self, *args, **kwargs): ... - def hideOutput(self, *args, **kwargs): ... - def inProbing(self, *args, **kwargs): ... - def inRepropagation(self, *args, **kwargs): ... - def includeBenders(self, *args, **kwargs): ... - def includeBendersDefaultCuts(self, *args, **kwargs): ... - def includeBenderscut(self, *args, **kwargs): ... - def includeBranchrule(self, *args, **kwargs): ... - def includeConshdlr(self, *args, **kwargs): ... - def includeCutsel(self, *args, **kwargs): ... - def includeDefaultPlugins(self, *args, **kwargs): ... - def includeEventhdlr(self, *args, **kwargs): ... - def includeHeur(self, *args, **kwargs): ... - def includeIISfinder(self, *args, **kwargs): ... - def includeNodesel(self, *args, **kwargs): ... - def includePresol(self, *args, **kwargs): ... - def includePricer(self, *args, **kwargs): ... - def includeProp(self, *args, **kwargs): ... - def includeReader(self, *args, **kwargs): ... - def includeRelax(self, *args, **kwargs): ... - def includeSepa(self, *args, **kwargs): ... - def infinity(self, *args, **kwargs): ... - def initBendersDefault(self, *args, **kwargs): ... - def interruptSolve(self, *args, **kwargs): ... - def isAndConsSorted(self, *args, **kwargs): ... - def isCutEfficacious(self, *args, **kwargs): ... - def isEQ(self, *args, **kwargs): ... - def isExact(self, *args, **kwargs): ... - def isFeasEQ(self, *args, **kwargs): ... - def isFeasGE(self, *args, **kwargs): ... - def isFeasGT(self, *args, **kwargs): ... - def isFeasIntegral(self, *args, **kwargs): ... - def isFeasLE(self, *args, **kwargs): ... - def isFeasLT(self, *args, **kwargs): ... - def isFeasNegative(self, *args, **kwargs): ... - def isFeasPositive(self, *args, **kwargs): ... - def isFeasZero(self, *args, **kwargs): ... - def isGE(self, *args, **kwargs): ... - def isGT(self, *args, **kwargs): ... - def isHugeValue(self, *args, **kwargs): ... - def isInfinity(self, *args, **kwargs): ... - def isLE(self, *args, **kwargs): ... - def isLPSolBasic(self, *args, **kwargs): ... - def isLT(self, *args, **kwargs): ... - def isNLPConstructed(self, *args, **kwargs): ... - def isNegative(self, *args, **kwargs): ... - def isObjChangedProbing(self, *args, **kwargs): ... - def isPositive(self, *args, **kwargs): ... - def isZero(self, *args, **kwargs): ... - def lpiGetIterations(self, *args, **kwargs): ... - def markDoNotAggrVar(self, *args, **kwargs): ... - def markDoNotMultaggrVar(self, *args, **kwargs): ... - def newProbingNode(self, *args, **kwargs): ... - def optimize(self, *args, **kwargs): ... - def optimizeNogil(self, *args, **kwargs): ... - def presolve(self, *args, **kwargs): ... - def printBestSol(self, *args, **kwargs): ... - def printCons(self, *args, **kwargs): ... - def printExternalCodeVersions(self, *args, **kwargs): ... - def printNlRow(self, *args, **kwargs): ... - def printProblem(self, *args, **kwargs): ... - def printRow(self, *args, **kwargs): ... - def printSol(self, *args, **kwargs): ... - def printStatistics(self, *args, **kwargs): ... - def printStatisticsJson(self, *args, **kwargs): ... - def printVersion(self, *args, **kwargs): ... - def propagateProbing(self, *args, **kwargs): ... - def readParams(self, *args, **kwargs): ... - def readProblem(self, *args, **kwargs): ... - def readSol(self, *args, **kwargs): ... - def readSolFile(self, *args, **kwargs): ... - def redirectOutput(self, *args, **kwargs): ... - def relax(self, *args, **kwargs): ... - def releaseRow(self, *args, **kwargs): ... - def repropagateNode(self, *args, **kwargs): ... - def resetParam(self, *args, **kwargs): ... - def resetParams(self, *args, **kwargs): ... - def restartSolve(self, *args, **kwargs): ... - def separateSol(self, *args, **kwargs): ... - def setBendersSubproblemIsConvex(self, *args, **kwargs): ... - def setBoolParam(self, *args, **kwargs): ... - def setCharParam(self, *args, **kwargs): ... - def setCheck(self, *args, **kwargs): ... - def setEmphasis(self, *args, **kwargs): ... - def setEnforced(self, *args, **kwargs): ... - def setHeurTiming(self, *args, **kwargs): ... - def setHeuristics(self, *args, **kwargs): ... - def setInitial(self, *args, **kwargs): ... - def setIntParam(self, *args, **kwargs): ... - def setLogfile(self, *args, **kwargs): ... - def setLongintParam(self, *args, **kwargs): ... - def setMaximize(self, *args, **kwargs): ... - def setMinimize(self, *args, **kwargs): ... - def setModifiable(self, *args, **kwargs): ... - def setObjIntegral(self, *args, **kwargs): ... - def setObjective(self, *args, **kwargs): ... - def setObjlimit(self, *args, **kwargs): ... - def setParam(self, *args, **kwargs): ... - def setParams(self, *args, **kwargs): ... - def setParamsCountsols(self, *args, **kwargs): ... - def setPresolve(self, *args, **kwargs): ... - def setProbName(self, *args, **kwargs): ... - def setRealParam(self, *args, **kwargs): ... - def setRelaxSolVal(self, *args, **kwargs): ... - def setRemovable(self, *args, **kwargs): ... - def setSeparating(self, *args, **kwargs): ... - def setSolVal(self, *args, **kwargs): ... - def setStringParam(self, *args, **kwargs): ... - def setupBendersSubproblem(self, *args, **kwargs): ... - def solveBendersSubproblem(self, *args, **kwargs): ... - def solveConcurrent(self, *args, **kwargs): ... - def solveDiveLP(self, *args, **kwargs): ... - def solveProbingLP(self, *args, **kwargs): ... - def sortAndCons(self, *args, **kwargs): ... - def startDive(self, *args, **kwargs): ... - def startProbing(self, *args, **kwargs): ... - def startStrongbranch(self, *args, **kwargs): ... - def tightenVarLb(self, *args, **kwargs): ... - def tightenVarLbGlobal(self, *args, **kwargs): ... - def tightenVarUb(self, *args, **kwargs): ... - def tightenVarUbGlobal(self, *args, **kwargs): ... - def to_ptr(self, *args, **kwargs): ... - def translateSubSol(self, *args, **kwargs): ... - def trySol(self, *args, **kwargs): ... - def updateBendersLowerbounds(self, *args, **kwargs): ... - def updateNodeLowerbound(self, *args, **kwargs): ... - def updateVarPseudocost(self, *args, **kwargs): ... - def version(self, *args, **kwargs): ... - def writeBestSol(self, *args, **kwargs): ... - def writeBestTransSol(self, *args, **kwargs): ... - def writeLP(self, *args, **kwargs): ... - def writeMIP(self, *args, **kwargs): ... - def writeName(self, *args, **kwargs): ... - def writeParams(self, *args, **kwargs): ... - def writeProblem(self, *args, **kwargs): ... - def writeSol(self, *args, **kwargs): ... - def writeStatistics(self, *args, **kwargs): ... - def writeStatisticsJson(self, *args, **kwargs): ... - def writeTransSol(self, *args, **kwargs): ... + def from_ptr(self, capsule: Incomplete, take_ownership: Incomplete = ...) -> Incomplete: ... + def generateIIS(self) -> Incomplete: ... + def getActivity(self, cons: Incomplete, sol: Incomplete = ...) -> Incomplete: ... + def getBendersAuxiliaryVar(self, probnumber: Incomplete, benders: Incomplete = ...) -> Incomplete: ... + def getBendersSubproblem(self, probnumber: Incomplete, benders: Incomplete = ...) -> Incomplete: ... + def getBendersVar(self, var: Incomplete, benders: Incomplete = ..., probnumber: Incomplete = ...) -> Incomplete: ... + def getBestChild(self) -> Incomplete: ... + def getBestLeaf(self) -> Incomplete: ... + def getBestNode(self) -> Incomplete: ... + def getBestSibling(self) -> Incomplete: ... + def getBestSol(self) -> Incomplete: ... + def getBestboundNode(self) -> Incomplete: ... + def getBipartiteGraphRepresentation(self, prev_col_features: Incomplete = ..., prev_edge_features: Incomplete = ..., prev_row_features: Incomplete = ..., static_only: Incomplete = ..., suppress_warnings: Incomplete = ...) -> Incomplete: ... + def getBranchScoreMultiple(self, var: Incomplete, gains: Incomplete) -> Incomplete: ... + def getCapacityKnapsack(self, cons: Incomplete) -> Incomplete: ... + def getChildren(self) -> Incomplete: ... + def getColRedCost(self, col: Incomplete) -> Incomplete: ... + def getCondition(self, exact: Incomplete = ...) -> Incomplete: ... + def getConsNVars(self, constraint: Incomplete) -> Incomplete: ... + def getConsVals(self, constraint: Incomplete) -> Incomplete: ... + def getConsVars(self, constraint: Incomplete) -> Incomplete: ... + def getConss(self, transformed: Incomplete = ...) -> Incomplete: ... + def getCurrentNode(self) -> Incomplete: ... + def getCutEfficacy(self, cut: Incomplete, sol: Incomplete = ...) -> Incomplete: ... + def getCutLPSolCutoffDistance(self, cut: Incomplete, sol: Incomplete) -> Incomplete: ... + def getCutoffbound(self) -> Incomplete: ... + def getDepth(self) -> Incomplete: ... + def getDualMultiplier(self, cons: Incomplete) -> Incomplete: ... + def getDualSolVal(self, cons: Incomplete, boundconstraint: Incomplete = ...) -> Incomplete: ... + def getDualbound(self) -> Incomplete: ... + def getDualboundRoot(self) -> Incomplete: ... + def getDualfarkasKnapsack(self, cons: Incomplete) -> Incomplete: ... + def getDualfarkasLinear(self, cons: Incomplete) -> Incomplete: ... + def getDualsolKnapsack(self, cons: Incomplete) -> Incomplete: ... + def getDualsolLinear(self, cons: Incomplete) -> Incomplete: ... + def getGap(self) -> Incomplete: ... + def getHeurTiming(self, heurname: Incomplete) -> Incomplete: ... + def getIIS(self) -> Incomplete: ... + def getLPBInvARow(self, row: Incomplete) -> Incomplete: ... + def getLPBInvRow(self, row: Incomplete) -> Incomplete: ... + def getLPBasisInd(self) -> Incomplete: ... + def getLPBranchCands(self) -> Incomplete: ... + def getLPColsData(self) -> Incomplete: ... + def getLPObjVal(self) -> Incomplete: ... + def getLPRowsData(self) -> Incomplete: ... + def getLPSolstat(self) -> Incomplete: ... + def getLeaves(self) -> Incomplete: ... + def getLhs(self, cons: Incomplete) -> Incomplete: ... + def getLinearConsIndicator(self, cons: Incomplete) -> Incomplete: ... + def getLocalEstimate(self, original: Incomplete = ...) -> Incomplete: ... + def getLowerbound(self) -> Incomplete: ... + def getMajorVersion(self) -> Incomplete: ... + def getMaxDepth(self) -> Incomplete: ... + def getMinorVersion(self) -> Incomplete: ... + def getNBestSolsFound(self) -> Incomplete: ... + def getNBinVars(self) -> Incomplete: ... + def getNChildren(self) -> Incomplete: ... + def getNConss(self, transformed: Incomplete = ...) -> Incomplete: ... + def getNContVars(self) -> Incomplete: ... + def getNCountedSols(self) -> Incomplete: ... + def getNCuts(self) -> Incomplete: ... + def getNCutsApplied(self) -> Incomplete: ... + def getNFeasibleLeaves(self) -> Incomplete: ... + def getNImplVars(self) -> Incomplete: ... + def getNInfeasibleLeaves(self) -> Incomplete: ... + def getNIntVars(self) -> Incomplete: ... + def getNLPBranchCands(self) -> Incomplete: ... + def getNLPCols(self) -> Incomplete: ... + def getNLPIterations(self) -> Incomplete: ... + def getNLPRows(self) -> Incomplete: ... + def getNLPs(self) -> Incomplete: ... + def getNLeaves(self) -> Incomplete: ... + def getNLimSolsFound(self) -> Incomplete: ... + def getNNlRows(self) -> Incomplete: ... + def getNNodeLPIterations(self) -> Incomplete: ... + def getNNodes(self) -> Incomplete: ... + def getNReaders(self) -> Incomplete: ... + def getNSepaRounds(self) -> Incomplete: ... + def getNSiblings(self) -> Incomplete: ... + def getNSols(self) -> Incomplete: ... + def getNSolsFound(self) -> Incomplete: ... + def getNStrongbranchLPIterations(self) -> Incomplete: ... + def getNTotalNodes(self) -> Incomplete: ... + def getNVars(self, transformed: Incomplete = ...) -> Incomplete: ... + def getNVarsAnd(self, and_cons: Incomplete) -> Incomplete: ... + def getNlRowActivityBounds(self, nlrow: Incomplete) -> Incomplete: ... + def getNlRowSolActivity(self, nlrow: Incomplete, sol: Incomplete = ...) -> Incomplete: ... + def getNlRowSolFeasibility(self, nlrow: Incomplete, sol: Incomplete = ...) -> Incomplete: ... + def getNlRows(self) -> Incomplete: ... + def getObjVal(self, original: Incomplete = ...) -> Incomplete: ... + def getObjective(self) -> Incomplete: ... + def getObjectiveSense(self) -> Incomplete: ... + def getObjlimit(self) -> Incomplete: ... + def getObjoffset(self, original: Incomplete = ...) -> Incomplete: ... + def getOpenNodes(self) -> Incomplete: ... + def getParam(self, name: Incomplete) -> Incomplete: ... + def getParams(self) -> Incomplete: ... + def getPlungeDepth(self) -> Incomplete: ... + def getPresolvingTime(self) -> Incomplete: ... + def getPrimalRay(self) -> Incomplete: ... + def getPrimalRayVal(self, var: Incomplete) -> Incomplete: ... + def getPrimalbound(self) -> Incomplete: ... + def getPrioChild(self) -> Incomplete: ... + def getPrioSibling(self) -> Incomplete: ... + def getProbName(self) -> Incomplete: ... + def getProbingDepth(self) -> Incomplete: ... + def getPseudoBranchCands(self) -> Incomplete: ... + def getReadingTime(self) -> Incomplete: ... + def getResultantAnd(self, and_cons: Incomplete) -> Incomplete: ... + def getRhs(self, cons: Incomplete) -> Incomplete: ... + def getRowActivity(self, row: Incomplete) -> Incomplete: ... + def getRowDualSol(self, row: Incomplete) -> Incomplete: ... + def getRowLPActivity(self, row: Incomplete) -> Incomplete: ... + def getRowLinear(self, cons: Incomplete) -> Incomplete: ... + def getRowNumIntCols(self, row: Incomplete) -> Incomplete: ... + def getRowObjParallelism(self, row: Incomplete) -> Incomplete: ... + def getRowParallelism(self, row1: Incomplete, row2: Incomplete, orthofunc: Incomplete = ...) -> Incomplete: ... + def getSiblings(self) -> Incomplete: ... + def getSlack(self, cons: Incomplete, sol: Incomplete = ..., side: Incomplete = ...) -> Incomplete: ... + def getSlackVarIndicator(self, cons: Incomplete) -> Incomplete: ... + def getSolObjVal(self, sol: Incomplete, original: Incomplete = ...) -> Incomplete: ... + def getSolTime(self, sol: Incomplete) -> Incomplete: ... + def getSolVal(self, sol: Incomplete, expr: Incomplete) -> Incomplete: ... + def getSols(self) -> Incomplete: ... + def getSolvingTime(self) -> Incomplete: ... + def getStage(self) -> Incomplete: ... + def getStageName(self) -> Incomplete: ... + def getStatus(self) -> Incomplete: ... + def getTechVersion(self) -> Incomplete: ... + def getTermsQuadratic(self, cons: Incomplete) -> Incomplete: ... + def getTotalTime(self) -> Incomplete: ... + def getTransformedCons(self, cons: Incomplete) -> Incomplete: ... + def getTransformedVar(self, var: Incomplete) -> Incomplete: ... + def getTreesizeEstimation(self) -> Incomplete: ... + def getVal(self, expr: Incomplete) -> Incomplete: ... + def getValsLinear(self, cons: Incomplete) -> Incomplete: ... + def getVarDict(self, transformed: Incomplete = ...) -> Incomplete: ... + def getVarLbDive(self, var: Incomplete) -> Incomplete: ... + def getVarPseudocost(self, var: Incomplete, branchdir: Incomplete) -> Incomplete: ... + def getVarPseudocostScore(self, var: Incomplete, solVal: Incomplete) -> Incomplete: ... + def getVarRedcost(self, var: Incomplete) -> Incomplete: ... + def getVarStrongbranch(self, var: Incomplete, itlim: Incomplete, idempotent: Incomplete = ..., integral: Incomplete = ...) -> Incomplete: ... + def getVarStrongbranchLast(self, var: Incomplete) -> Incomplete: ... + def getVarStrongbranchNode(self, var: Incomplete) -> Incomplete: ... + def getVarUbDive(self, var: Incomplete) -> Incomplete: ... + def getVars(self, transformed: Incomplete = ...) -> Incomplete: ... + def getVarsAnd(self, and_cons: Incomplete) -> Incomplete: ... + def getWeightsKnapsack(self, cons: Incomplete) -> Incomplete: ... + def hasPrimalRay(self) -> Incomplete: ... + def hideOutput(self, quiet: Incomplete = ...) -> Incomplete: ... + def inProbing(self) -> Incomplete: ... + def inRepropagation(self) -> Incomplete: ... + def includeBenders(self, benders: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete = ..., cutlp: Incomplete = ..., cutpseudo: Incomplete = ..., cutrelax: Incomplete = ..., shareaux: Incomplete = ...) -> Incomplete: ... + def includeBendersDefaultCuts(self, benders: Incomplete) -> Incomplete: ... + def includeBenderscut(self, benders: Incomplete, benderscut: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete = ..., islpcut: Incomplete = ...) -> Incomplete: ... + def includeBranchrule(self, branchrule: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete, maxdepth: Incomplete, maxbounddist: Incomplete) -> Incomplete: ... + def includeConshdlr(self, conshdlr: Incomplete, name: Incomplete, desc: Incomplete, sepapriority: Incomplete = ..., enfopriority: Incomplete = ..., chckpriority: Incomplete = ..., sepafreq: Incomplete = ..., propfreq: Incomplete = ..., eagerfreq: Incomplete = ..., maxprerounds: Incomplete = ..., delaysepa: Incomplete = ..., delayprop: Incomplete = ..., needscons: Incomplete = ..., proptiming: Incomplete = ..., presoltiming: Incomplete = ...) -> Incomplete: ... + def includeCutsel(self, cutsel: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete) -> Incomplete: ... + def includeDefaultPlugins(self) -> Incomplete: ... + def includeEventhdlr(self, eventhdlr: Incomplete, name: Incomplete, desc: Incomplete) -> Incomplete: ... + def includeHeur(self, heur: Incomplete, name: Incomplete, desc: Incomplete, dispchar: Incomplete, priority: Incomplete = ..., freq: Incomplete = ..., freqofs: Incomplete = ..., maxdepth: Incomplete = ..., timingmask: Incomplete = ..., usessubscip: Incomplete = ...) -> Incomplete: ... + def includeIISfinder(self, iisfinder: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete = ..., freq: Incomplete = ...) -> Incomplete: ... + def includeNodesel(self, nodesel: Incomplete, name: Incomplete, desc: Incomplete, stdpriority: Incomplete, memsavepriority: Incomplete) -> Incomplete: ... + def includePresol(self, presol: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete, maxrounds: Incomplete, timing: Incomplete = ...) -> Incomplete: ... + def includePricer(self, pricer: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete = ..., delay: Incomplete = ...) -> Incomplete: ... + def includeProp(self, prop: Incomplete, name: Incomplete, desc: Incomplete, presolpriority: Incomplete, presolmaxrounds: Incomplete, proptiming: Incomplete, presoltiming: Incomplete = ..., priority: Incomplete = ..., freq: Incomplete = ..., delay: Incomplete = ...) -> Incomplete: ... + def includeReader(self, reader: Incomplete, name: Incomplete, desc: Incomplete, ext: Incomplete) -> Incomplete: ... + def includeRelax(self, relax: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete = ..., freq: Incomplete = ...) -> Incomplete: ... + def includeSepa(self, sepa: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete = ..., freq: Incomplete = ..., maxbounddist: Incomplete = ..., usessubscip: Incomplete = ..., delay: Incomplete = ...) -> Incomplete: ... + def infinity(self) -> Incomplete: ... + def initBendersDefault(self, subproblems: Incomplete) -> Incomplete: ... + def interruptSolve(self) -> Incomplete: ... + def isAndConsSorted(self, and_cons: Incomplete) -> Incomplete: ... + def isCutEfficacious(self, cut: Incomplete, sol: Incomplete = ...) -> Incomplete: ... + def isEQ(self, val1: Incomplete, val2: Incomplete) -> Incomplete: ... + def isExact(self) -> Incomplete: ... + def isFeasEQ(self, val1: Incomplete, val2: Incomplete) -> Incomplete: ... + def isFeasGE(self, val1: Incomplete, val2: Incomplete) -> Incomplete: ... + def isFeasGT(self, val1: Incomplete, val2: Incomplete) -> Incomplete: ... + def isFeasIntegral(self, value: Incomplete) -> Incomplete: ... + def isFeasLE(self, val1: Incomplete, val2: Incomplete) -> Incomplete: ... + def isFeasLT(self, val1: Incomplete, val2: Incomplete) -> Incomplete: ... + def isFeasNegative(self, value: Incomplete) -> Incomplete: ... + def isFeasPositive(self, value: Incomplete) -> Incomplete: ... + def isFeasZero(self, value: Incomplete) -> Incomplete: ... + def isGE(self, val1: Incomplete, val2: Incomplete) -> Incomplete: ... + def isGT(self, val1: Incomplete, val2: Incomplete) -> Incomplete: ... + def isHugeValue(self, val: Incomplete) -> Incomplete: ... + def isInfinity(self, value: Incomplete) -> Incomplete: ... + def isLE(self, val1: Incomplete, val2: Incomplete) -> Incomplete: ... + def isLPSolBasic(self) -> Incomplete: ... + def isLT(self, val1: Incomplete, val2: Incomplete) -> Incomplete: ... + def isNLPConstructed(self) -> Incomplete: ... + def isNegative(self, val: Incomplete) -> Incomplete: ... + def isObjChangedProbing(self) -> Incomplete: ... + def isPositive(self, val: Incomplete) -> Incomplete: ... + def isZero(self, value: Incomplete) -> Incomplete: ... + def lpiGetIterations(self) -> Incomplete: ... + def markDoNotAggrVar(self, var: Incomplete) -> Incomplete: ... + def markDoNotMultaggrVar(self, var: Incomplete) -> Incomplete: ... + def newProbingNode(self) -> Incomplete: ... + def optimize(self) -> Incomplete: ... + def optimizeNogil(self) -> Incomplete: ... + def presolve(self) -> Incomplete: ... + def printBestSol(self, write_zeros: Incomplete = ...) -> Incomplete: ... + def printCons(self, constraint: Incomplete) -> Incomplete: ... + def printExternalCodeVersions(self) -> Incomplete: ... + def printNlRow(self, nlrow: Incomplete) -> Incomplete: ... + def printProblem(self, ext: Incomplete = ..., trans: Incomplete = ..., genericnames: Incomplete = ...) -> Incomplete: ... + def printRow(self, row: Incomplete) -> Incomplete: ... + def printSol(self, solution: Incomplete = ..., write_zeros: Incomplete = ...) -> Incomplete: ... + def printStatistics(self, filename: Incomplete = ...) -> Incomplete: ... + def printStatisticsJson(self) -> Incomplete: ... + def printVersion(self) -> Incomplete: ... + def propagateProbing(self, maxproprounds: Incomplete) -> Incomplete: ... + def readParams(self, file: Incomplete) -> Incomplete: ... + def readProblem(self, filename: Incomplete, extension: Incomplete = ...) -> Incomplete: ... + def readSol(self, filename: Incomplete) -> Incomplete: ... + def readSolFile(self, filename: Incomplete) -> Incomplete: ... + def redirectOutput(self) -> Incomplete: ... + def relax(self) -> Incomplete: ... + def releaseRow(self, row: Incomplete) -> Incomplete: ... + def repropagateNode(self, node: Incomplete) -> Incomplete: ... + def resetParam(self, name: Incomplete) -> Incomplete: ... + def resetParams(self) -> Incomplete: ... + def restartSolve(self) -> Incomplete: ... + def separateSol(self, sol: Incomplete = ..., pretendroot: Incomplete = ..., allowlocal: Incomplete = ..., onlydelayed: Incomplete = ...) -> Incomplete: ... + def setBendersSubproblemIsConvex(self, benders: Incomplete, probnumber: Incomplete, isconvex: Incomplete = ...) -> Incomplete: ... + def setBoolParam(self, name: Incomplete, value: Incomplete) -> Incomplete: ... + def setCharParam(self, name: Incomplete, value: Incomplete) -> Incomplete: ... + def setCheck(self, cons: Incomplete, newCheck: Incomplete) -> Incomplete: ... + def setEmphasis(self, paraemphasis: Incomplete, quiet: Incomplete = ...) -> Incomplete: ... + def setEnforced(self, cons: Incomplete, newEnf: Incomplete) -> Incomplete: ... + def setHeurTiming(self, heurname: Incomplete, heurtiming: Incomplete) -> Incomplete: ... + def setHeuristics(self, setting: Incomplete) -> Incomplete: ... + def setInitial(self, cons: Incomplete, newInit: Incomplete) -> Incomplete: ... + def setIntParam(self, name: Incomplete, value: Incomplete) -> Incomplete: ... + def setLogfile(self, path: Incomplete) -> Incomplete: ... + def setLongintParam(self, name: Incomplete, value: Incomplete) -> Incomplete: ... + def setMaximize(self) -> Incomplete: ... + def setMinimize(self) -> Incomplete: ... + def setModifiable(self, cons: Incomplete, newMod: Incomplete) -> Incomplete: ... + def setObjIntegral(self) -> Incomplete: ... + def setObjective(self, expr: Incomplete, sense: Incomplete = ..., clear: Incomplete = ...) -> Incomplete: ... + def setObjlimit(self, objlimit: Incomplete) -> Incomplete: ... + def setParam(self, name: Incomplete, value: Incomplete) -> Incomplete: ... + def setParams(self, params: Incomplete) -> Incomplete: ... + def setParamsCountsols(self) -> Incomplete: ... + def setPresolve(self, setting: Incomplete) -> Incomplete: ... + def setProbName(self, name: Incomplete) -> Incomplete: ... + def setRealParam(self, name: Incomplete, value: Incomplete) -> Incomplete: ... + def setRelaxSolVal(self, var: Incomplete, val: Incomplete) -> Incomplete: ... + def setRemovable(self, cons: Incomplete, newRem: Incomplete) -> Incomplete: ... + def setSeparating(self, setting: Incomplete) -> Incomplete: ... + def setSolVal(self, solution: Incomplete, var: Incomplete, val: Incomplete) -> Incomplete: ... + def setStringParam(self, name: Incomplete, value: Incomplete) -> Incomplete: ... + def setupBendersSubproblem(self, probnumber: Incomplete, benders: Incomplete = ..., solution: Incomplete = ..., checktype: Incomplete = ...) -> Incomplete: ... + def solveBendersSubproblem(self, probnumber: Incomplete, solvecip: Incomplete, benders: Incomplete = ..., solution: Incomplete = ...) -> Incomplete: ... + def solveConcurrent(self) -> Incomplete: ... + def solveDiveLP(self, itlim: Incomplete = ...) -> Incomplete: ... + def solveProbingLP(self, itlim: Incomplete = ...) -> Incomplete: ... + def sortAndCons(self, and_cons: Incomplete) -> Incomplete: ... + def startDive(self) -> Incomplete: ... + def startProbing(self) -> Incomplete: ... + def startStrongbranch(self) -> Incomplete: ... + def tightenVarLb(self, var: Incomplete, lb: Incomplete, force: Incomplete = ...) -> Incomplete: ... + def tightenVarLbGlobal(self, var: Incomplete, lb: Incomplete, force: Incomplete = ...) -> Incomplete: ... + def tightenVarUb(self, var: Incomplete, ub: Incomplete, force: Incomplete = ...) -> Incomplete: ... + def tightenVarUbGlobal(self, var: Incomplete, ub: Incomplete, force: Incomplete = ...) -> Incomplete: ... + def to_ptr(self, give_ownership: Incomplete) -> Incomplete: ... + def translateSubSol(self, sub_model: Incomplete, sol: Incomplete, heur: Incomplete) -> Incomplete: ... + def trySol(self, solution: Incomplete, printreason: Incomplete = ..., completely: Incomplete = ..., checkbounds: Incomplete = ..., checkintegrality: Incomplete = ..., checklprows: Incomplete = ..., free: Incomplete = ...) -> Incomplete: ... + def updateBendersLowerbounds(self, lowerbounds: Incomplete, benders: Incomplete = ...) -> Incomplete: ... + def updateNodeLowerbound(self, node: Incomplete, lb: Incomplete) -> Incomplete: ... + def updateVarPseudocost(self, var: Incomplete, valdelta: Incomplete, objdelta: Incomplete, weight: Incomplete) -> Incomplete: ... + def version(self) -> Incomplete: ... + def writeBestSol(self, filename: Incomplete = ..., write_zeros: Incomplete = ...) -> Incomplete: ... + def writeBestTransSol(self, filename: Incomplete = ..., write_zeros: Incomplete = ...) -> Incomplete: ... + def writeLP(self, filename: Incomplete = ...) -> Incomplete: ... + def writeMIP(self, filename: Incomplete, genericnames: Incomplete = ..., origobj: Incomplete = ..., lazyconss: Incomplete = ...) -> Incomplete: ... + def writeName(self, var: Incomplete) -> Incomplete: ... + def writeParams(self, filename: Incomplete = ..., comments: Incomplete = ..., onlychanged: Incomplete = ..., verbose: Incomplete = ...) -> Incomplete: ... + def writeProblem(self, filename: Incomplete = ..., trans: Incomplete = ..., genericnames: Incomplete = ..., verbose: Incomplete = ...) -> Incomplete: ... + def writeSol(self, solution: Incomplete, filename: Incomplete = ..., write_zeros: Incomplete = ...) -> Incomplete: ... + def writeStatistics(self, filename: Incomplete = ...) -> Incomplete: ... + def writeStatisticsJson(self, filename: Incomplete = ...) -> Incomplete: ... + def writeTransSol(self, solution: Incomplete, filename: Incomplete = ..., write_zeros: Incomplete = ...) -> Incomplete: ... def __eq__(self, other: object) -> bool: ... def __ge__(self, other: object) -> bool: ... def __gt__(self, other: object) -> bool: ... @@ -844,12 +844,12 @@ class Model: class NLRow: data: Incomplete name: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def getConstant(self, *args, **kwargs): ... - def getDualsol(self, *args, **kwargs): ... - def getLhs(self, *args, **kwargs): ... - def getLinearTerms(self, *args, **kwargs): ... - def getRhs(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def getConstant(self) -> Incomplete: ... + def getDualsol(self) -> Incomplete: ... + def getLhs(self) -> Incomplete: ... + def getLinearTerms(self) -> Incomplete: ... + def getRhs(self) -> Incomplete: ... def __eq__(self, other: object) -> bool: ... def __ge__(self, other: object) -> bool: ... def __gt__(self, other: object) -> bool: ... @@ -860,21 +860,21 @@ class NLRow: class Node: data: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def getAddedConss(self, *args, **kwargs): ... - def getDepth(self, *args, **kwargs): ... - def getDomchg(self, *args, **kwargs): ... - def getEstimate(self, *args, **kwargs): ... - def getLowerbound(self, *args, **kwargs): ... - def getNAddedConss(self, *args, **kwargs): ... - def getNDomchg(self, *args, **kwargs): ... - def getNParentBranchings(self, *args, **kwargs): ... - def getNumber(self, *args, **kwargs): ... - def getParent(self, *args, **kwargs): ... - def getParentBranchings(self, *args, **kwargs): ... - def getType(self, *args, **kwargs): ... - def isActive(self, *args, **kwargs): ... - def isPropagatedAgain(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def getAddedConss(self) -> Incomplete: ... + def getDepth(self) -> Incomplete: ... + def getDomchg(self) -> Incomplete: ... + def getEstimate(self) -> Incomplete: ... + def getLowerbound(self) -> Incomplete: ... + def getNAddedConss(self) -> Incomplete: ... + def getNDomchg(self) -> Incomplete: ... + def getNParentBranchings(self) -> Incomplete: ... + def getNumber(self) -> Incomplete: ... + def getParent(self) -> Incomplete: ... + def getParentBranchings(self) -> Incomplete: ... + def getType(self) -> Incomplete: ... + def isActive(self) -> Incomplete: ... + def isPropagatedAgain(self) -> Incomplete: ... def __eq__(self, other: object) -> bool: ... def __ge__(self, other: object) -> bool: ... def __gt__(self, other: object) -> bool: ... @@ -885,14 +885,14 @@ class Node: class Nodesel: model: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def nodecomp(self, *args, **kwargs): ... - def nodeexit(self, *args, **kwargs): ... - def nodeexitsol(self, *args, **kwargs): ... - def nodefree(self, *args, **kwargs): ... - def nodeinit(self, *args, **kwargs): ... - def nodeinitsol(self, *args, **kwargs): ... - def nodeselect(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def nodecomp(self, node1: Incomplete, node2: Incomplete) -> Incomplete: ... + def nodeexit(self) -> Incomplete: ... + def nodeexitsol(self) -> Incomplete: ... + def nodefree(self) -> Incomplete: ... + def nodeinit(self) -> Incomplete: ... + def nodeinitsol(self) -> Incomplete: ... + def nodeselect(self) -> Incomplete: ... class Op: add: ClassVar[str] = ... @@ -916,14 +916,14 @@ class PY_SCIP_BENDERSENFOTYPE: LP: ClassVar[int] = ... PSEUDO: ClassVar[int] = ... RELAX: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_BRANCHDIR: AUTO: ClassVar[int] = ... DOWNWARDS: ClassVar[int] = ... FIXED: ClassVar[int] = ... UPWARDS: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_EVENTTYPE: BESTSOLFOUND: ClassVar[int] = ... @@ -982,7 +982,7 @@ class PY_SCIP_EVENTTYPE: VAREVENT: ClassVar[int] = ... VARFIXED: ClassVar[int] = ... VARUNLOCKED: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_HEURTIMING: AFTERLPLOOP: ClassVar[int] = ... @@ -996,18 +996,18 @@ class PY_SCIP_HEURTIMING: DURINGLPLOOP: ClassVar[int] = ... DURINGPRESOLLOOP: ClassVar[int] = ... DURINGPRICINGLOOP: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_IMPLINTTYPE: NONE: ClassVar[int] = ... STRONG: ClassVar[int] = ... WEAK: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_LOCKTYPE: CONFLICT: ClassVar[int] = ... MODEL: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_LPPARAM: BARRIERCONVTOL: ClassVar[int] = ... @@ -1030,7 +1030,7 @@ class PY_SCIP_LPPARAM: SCALING: ClassVar[int] = ... THREADS: ClassVar[int] = ... TIMING: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_LPSOLSTAT: ERROR: ClassVar[int] = ... @@ -1041,7 +1041,7 @@ class PY_SCIP_LPSOLSTAT: OPTIMAL: ClassVar[int] = ... TIMELIMIT: ClassVar[int] = ... UNBOUNDEDRAY: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_NODETYPE: CHILD: ClassVar[int] = ... @@ -1055,7 +1055,7 @@ class PY_SCIP_NODETYPE: REFOCUSNODE: ClassVar[int] = ... SIBLING: ClassVar[int] = ... SUBROOT: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_PARAMEMPHASIS: BENCHMARK: ClassVar[int] = ... @@ -1070,28 +1070,28 @@ class PY_SCIP_PARAMEMPHASIS: PHASEFEAS: ClassVar[int] = ... PHASEIMPROVE: ClassVar[int] = ... PHASEPROOF: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_PARAMSETTING: AGGRESSIVE: ClassVar[int] = ... DEFAULT: ClassVar[int] = ... FAST: ClassVar[int] = ... OFF: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_PRESOLTIMING: EXHAUSTIVE: ClassVar[int] = ... FAST: ClassVar[int] = ... MEDIUM: ClassVar[int] = ... NONE: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_PROPTIMING: AFTERLPLOOP: ClassVar[int] = ... AFTERLPNODE: ClassVar[int] = ... BEFORELP: ClassVar[int] = ... DURINGLPLOOP: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_RESULT: BRANCHED: ClassVar[int] = ... @@ -1111,14 +1111,14 @@ class PY_SCIP_RESULT: SUCCESS: ClassVar[int] = ... SUSPENDED: ClassVar[int] = ... UNBOUNDED: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_ROWORIGINTYPE: CONS: ClassVar[int] = ... REOPT: ClassVar[int] = ... SEPA: ClassVar[int] = ... UNSPEC: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_SOLORIGIN: LPSOL: ClassVar[int] = ... @@ -1129,7 +1129,7 @@ class PY_SCIP_SOLORIGIN: RELAXSOL: ClassVar[int] = ... UNKNOWN: ClassVar[int] = ... ZERO: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_STAGE: EXITPRESOLVE: ClassVar[int] = ... @@ -1146,7 +1146,7 @@ class PY_SCIP_STAGE: SOLVING: ClassVar[int] = ... TRANSFORMED: ClassVar[int] = ... TRANSFORMING: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PY_SCIP_STATUS: BESTSOLLIMIT: ClassVar[int] = ... @@ -1166,7 +1166,7 @@ class PY_SCIP_STATUS: UNBOUNDED: ClassVar[int] = ... UNKNOWN: ClassVar[int] = ... USERINTERRUPT: ClassVar[int] = ... - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class PowExpr(GenExpr): expo: Incomplete @@ -1174,24 +1174,24 @@ class PowExpr(GenExpr): class Presol: model: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def presolexec(self, *args, **kwargs): ... - def presolexit(self, *args, **kwargs): ... - def presolexitpre(self, *args, **kwargs): ... - def presolfree(self, *args, **kwargs): ... - def presolinit(self, *args, **kwargs): ... - def presolinitpre(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def presolexec(self, nrounds: Incomplete, presoltiming: Incomplete) -> Incomplete: ... + def presolexit(self) -> Incomplete: ... + def presolexitpre(self) -> Incomplete: ... + def presolfree(self) -> Incomplete: ... + def presolinit(self) -> Incomplete: ... + def presolinitpre(self) -> Incomplete: ... class Pricer: model: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def pricerexit(self, *args, **kwargs): ... - def pricerexitsol(self, *args, **kwargs): ... - def pricerfarkas(self, *args, **kwargs): ... - def pricerfree(self, *args, **kwargs): ... - def pricerinit(self, *args, **kwargs): ... - def pricerinitsol(self, *args, **kwargs): ... - def pricerredcost(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def pricerexit(self) -> Incomplete: ... + def pricerexitsol(self) -> Incomplete: ... + def pricerfarkas(self) -> Incomplete: ... + def pricerfree(self) -> Incomplete: ... + def pricerinit(self) -> Incomplete: ... + def pricerinitsol(self) -> Incomplete: ... + def pricerredcost(self) -> Incomplete: ... class ProdExpr(GenExpr): constant: Incomplete @@ -1199,61 +1199,61 @@ class ProdExpr(GenExpr): class Prop: model: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def propexec(self, *args, **kwargs): ... - def propexit(self, *args, **kwargs): ... - def propexitpre(self, *args, **kwargs): ... - def propexitsol(self, *args, **kwargs): ... - def propfree(self, *args, **kwargs): ... - def propinit(self, *args, **kwargs): ... - def propinitpre(self, *args, **kwargs): ... - def propinitsol(self, *args, **kwargs): ... - def proppresol(self, *args, **kwargs): ... - def propresprop(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def propexec(self, proptiming: Incomplete) -> Incomplete: ... + def propexit(self) -> Incomplete: ... + def propexitpre(self) -> Incomplete: ... + def propexitsol(self, restart: Incomplete) -> Incomplete: ... + def propfree(self) -> Incomplete: ... + def propinit(self) -> Incomplete: ... + def propinitpre(self) -> Incomplete: ... + def propinitsol(self) -> Incomplete: ... + def proppresol(self, nrounds: Incomplete, presoltiming: Incomplete, result_dict: Incomplete) -> Incomplete: ... + def propresprop(self, confvar: Incomplete, inferinfo: Incomplete, bdtype: Incomplete, relaxedbd: Incomplete) -> Incomplete: ... class Reader: model: Incomplete name: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def readerfree(self, *args, **kwargs): ... - def readerread(self, *args, **kwargs): ... - def readerwrite(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def readerfree(self) -> Incomplete: ... + def readerread(self, filename: Incomplete) -> Incomplete: ... + def readerwrite(self, file: Incomplete, name: Incomplete, transformed: Incomplete, objsense: Incomplete, objoffset: Incomplete, objscale: Incomplete, binvars: Incomplete, intvars: Incomplete, implvars: Incomplete, contvars: Incomplete, fixedvars: Incomplete, startnvars: Incomplete, conss: Incomplete, maxnconss: Incomplete, startnconss: Incomplete, genericnames: Incomplete) -> Incomplete: ... class Relax: model: Incomplete name: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def relaxexec(self, *args, **kwargs): ... - def relaxexit(self, *args, **kwargs): ... - def relaxexitsol(self, *args, **kwargs): ... - def relaxfree(self, *args, **kwargs): ... - def relaxinit(self, *args, **kwargs): ... - def relaxinitsol(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def relaxexec(self) -> Incomplete: ... + def relaxexit(self) -> Incomplete: ... + def relaxexitsol(self) -> Incomplete: ... + def relaxfree(self) -> Incomplete: ... + def relaxinit(self) -> Incomplete: ... + def relaxinitsol(self) -> Incomplete: ... class Row: data: Incomplete name: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def getAge(self, *args, **kwargs): ... - def getBasisStatus(self, *args, **kwargs): ... - def getCols(self, *args, **kwargs): ... - def getConsOriginConshdlrtype(self, *args, **kwargs): ... - def getConstant(self, *args, **kwargs): ... - def getDualfarkas(self, *args, **kwargs): ... - def getDualsol(self, *args, **kwargs): ... - def getLPPos(self, *args, **kwargs): ... - def getLhs(self, *args, **kwargs): ... - def getNLPNonz(self, *args, **kwargs): ... - def getNNonz(self, *args, **kwargs): ... - def getNorm(self, *args, **kwargs): ... - def getOrigintype(self, *args, **kwargs): ... - def getRhs(self, *args, **kwargs): ... - def getVals(self, *args, **kwargs): ... - def isInGlobalCutpool(self, *args, **kwargs): ... - def isIntegral(self, *args, **kwargs): ... - def isLocal(self, *args, **kwargs): ... - def isModifiable(self, *args, **kwargs): ... - def isRemovable(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def getAge(self) -> Incomplete: ... + def getBasisStatus(self) -> Incomplete: ... + def getCols(self) -> Incomplete: ... + def getConsOriginConshdlrtype(self) -> Incomplete: ... + def getConstant(self) -> Incomplete: ... + def getDualfarkas(self) -> Incomplete: ... + def getDualsol(self) -> Incomplete: ... + def getLPPos(self) -> Incomplete: ... + def getLhs(self) -> Incomplete: ... + def getNLPNonz(self) -> Incomplete: ... + def getNNonz(self) -> Incomplete: ... + def getNorm(self) -> Incomplete: ... + def getOrigintype(self) -> Incomplete: ... + def getRhs(self) -> Incomplete: ... + def getVals(self) -> Incomplete: ... + def isInGlobalCutpool(self) -> Incomplete: ... + def isIntegral(self) -> Incomplete: ... + def isLocal(self) -> Incomplete: ... + def isModifiable(self) -> Incomplete: ... + def isRemovable(self) -> Incomplete: ... def __eq__(self, other: object) -> bool: ... def __ge__(self, other: object) -> bool: ... def __gt__(self, other: object) -> bool: ... @@ -1264,28 +1264,28 @@ class Row: class RowExact: data: Incomplete - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self) -> None: ... class Sepa: model: Incomplete name: Incomplete - def __init__(self, *args, **kwargs) -> None: ... - def sepaexeclp(self, *args, **kwargs): ... - def sepaexecsol(self, *args, **kwargs): ... - def sepaexit(self, *args, **kwargs): ... - def sepaexitsol(self, *args, **kwargs): ... - def sepafree(self, *args, **kwargs): ... - def sepainit(self, *args, **kwargs): ... - def sepainitsol(self, *args, **kwargs): ... + def __init__(self) -> None: ... + def sepaexeclp(self) -> Incomplete: ... + def sepaexecsol(self, solution: Incomplete) -> Incomplete: ... + def sepaexit(self) -> Incomplete: ... + def sepaexitsol(self) -> Incomplete: ... + def sepafree(self) -> Incomplete: ... + def sepainit(self) -> Incomplete: ... + def sepainitsol(self) -> Incomplete: ... class Solution: data: Incomplete def __init__(self, *args, **kwargs) -> None: ... - def _checkStage(self, *args, **kwargs): ... - def _evaluate(self, *args, **kwargs): ... - def getOrigin(self, *args, **kwargs): ... - def retransform(self, *args, **kwargs): ... - def translate(self, *args, **kwargs): ... + def _checkStage(self, method: Incomplete) -> Incomplete: ... + def _evaluate(self, term: Incomplete) -> Incomplete: ... + def getOrigin(self) -> Incomplete: ... + def retransform(self) -> Incomplete: ... + def translate(self, target: Incomplete) -> Incomplete: ... def __delitem__(self, other) -> None: ... def __getitem__(self, index): ... def __setitem__(self, index, object) -> None: ... @@ -1346,7 +1346,7 @@ class Term: hashval: Incomplete ptrtuple: Incomplete vartuple: Incomplete - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self, *args: Incomplete) -> None: ... def __add__(self, other): ... def __eq__(self, other: object) -> bool: ... def __getitem__(self, index): ... @@ -1364,38 +1364,38 @@ class Variable(Expr): data: Incomplete name: Incomplete def __init__(self, *args, **kwargs) -> None: ... - def getAvgSol(self, *args, **kwargs): ... - def getCol(self, *args, **kwargs): ... - def getImplType(self, *args, **kwargs): ... - def getIndex(self, *args, **kwargs): ... - def getLPSol(self, *args, **kwargs): ... - def getLbGlobal(self, *args, **kwargs): ... - def getLbLocal(self, *args, **kwargs): ... - def getLbOriginal(self, *args, **kwargs): ... - def getNBranchings(self, *args, **kwargs): ... - def getNBranchingsCurrentRun(self, *args, **kwargs): ... - def getNLocksDown(self, *args, **kwargs): ... - def getNLocksDownType(self, *args, **kwargs): ... - def getNLocksUp(self, *args, **kwargs): ... - def getNLocksUpType(self, *args, **kwargs): ... - def getObj(self, *args, **kwargs): ... - def getStatus(self, *args, **kwargs): ... - def getUbGlobal(self, *args, **kwargs): ... - def getUbLocal(self, *args, **kwargs): ... - def getUbOriginal(self, *args, **kwargs): ... - def isActive(self, *args, **kwargs): ... - def isBinary(self, *args, **kwargs): ... - def isDeletable(self, *args, **kwargs): ... - def isImpliedIntegral(self, *args, **kwargs): ... - def isInLP(self, *args, **kwargs): ... - def isIntegral(self, *args, **kwargs): ... - def isNonImpliedIntegral(self, *args, **kwargs): ... - def isOriginal(self, *args, **kwargs): ... - def isRelaxationOnly(self, *args, **kwargs): ... - def markRelaxationOnly(self, *args, **kwargs): ... - def ptr(self, *args, **kwargs): ... - def varMayRound(self, *args, **kwargs): ... - def vtype(self, *args, **kwargs): ... + def getAvgSol(self) -> Incomplete: ... + def getCol(self) -> Incomplete: ... + def getImplType(self) -> Incomplete: ... + def getIndex(self) -> Incomplete: ... + def getLPSol(self) -> Incomplete: ... + def getLbGlobal(self) -> Incomplete: ... + def getLbLocal(self) -> Incomplete: ... + def getLbOriginal(self) -> Incomplete: ... + def getNBranchings(self, branchdir: Incomplete) -> Incomplete: ... + def getNBranchingsCurrentRun(self, branchdir: Incomplete) -> Incomplete: ... + def getNLocksDown(self) -> Incomplete: ... + def getNLocksDownType(self, locktype: Incomplete) -> Incomplete: ... + def getNLocksUp(self) -> Incomplete: ... + def getNLocksUpType(self, locktype: Incomplete) -> Incomplete: ... + def getObj(self) -> Incomplete: ... + def getStatus(self) -> Incomplete: ... + def getUbGlobal(self) -> Incomplete: ... + def getUbLocal(self) -> Incomplete: ... + def getUbOriginal(self) -> Incomplete: ... + def isActive(self) -> Incomplete: ... + def isBinary(self) -> Incomplete: ... + def isDeletable(self) -> Incomplete: ... + def isImpliedIntegral(self) -> Incomplete: ... + def isInLP(self) -> Incomplete: ... + def isIntegral(self) -> Incomplete: ... + def isNonImpliedIntegral(self) -> Incomplete: ... + def isOriginal(self) -> Incomplete: ... + def isRelaxationOnly(self) -> Incomplete: ... + def markRelaxationOnly(self) -> Incomplete: ... + def ptr(self) -> Incomplete: ... + def varMayRound(self, direction: Incomplete = ...) -> Incomplete: ... + def vtype(self) -> Incomplete: ... class _VarArray: def __init__(self, *args, **kwargs) -> None: ... From 2fe3201136e296c42327e6fa93260e6c98f8aee0 Mon Sep 17 00:00:00 2001 From: Jonathan Berthias Date: Mon, 29 Dec 2025 15:22:19 +0100 Subject: [PATCH 04/15] Mark disjoint_base classes --- src/pyscipopt/scip.pyi | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/src/pyscipopt/scip.pyi b/src/pyscipopt/scip.pyi index 1c6cb298d..9649d226b 100644 --- a/src/pyscipopt/scip.pyi +++ b/src/pyscipopt/scip.pyi @@ -1,5 +1,6 @@ from dataclasses import dataclass from typing import ClassVar +from typing_extensions import disjoint_base import numpy from _typeshed import Incomplete @@ -32,6 +33,7 @@ sqrt: Incomplete str_conversion: Incomplete value_to_array: Incomplete +@disjoint_base class Benders: model: Incomplete name: Incomplete @@ -51,6 +53,7 @@ class Benders: def benderssolvesub(self, solution: Incomplete, probnumber: Incomplete) -> Incomplete: ... def benderssolvesubconvex(self, solution: Incomplete, probnumber: Incomplete, onlyconvex: Incomplete) -> Incomplete: ... +@disjoint_base class Benderscut: benders: Incomplete model: Incomplete @@ -63,6 +66,7 @@ class Benderscut: def benderscutinit(self) -> Incomplete: ... def benderscutinitsol(self) -> Incomplete: ... +@disjoint_base class BoundChange: def __init__(self) -> None: ... def getBoundchgtype(self) -> Incomplete: ... @@ -71,6 +75,7 @@ class BoundChange: def getVar(self) -> Incomplete: ... def isRedundant(self) -> Incomplete: ... +@disjoint_base class Branchrule: model: Incomplete def __init__(self) -> None: ... @@ -83,6 +88,7 @@ class Branchrule: def branchinit(self) -> Incomplete: ... def branchinitsol(self) -> Incomplete: ... +@disjoint_base class Column: data: Incomplete def __init__(self) -> None: ... @@ -103,10 +109,12 @@ class Column: def __lt__(self, other: object) -> bool: ... def __ne__(self, other: object) -> bool: ... +@disjoint_base class ColumnExact: data: Incomplete def __init__(self) -> None: ... +@disjoint_base class Conshdlr: model: Incomplete name: Incomplete @@ -145,10 +153,12 @@ class Conshdlr: def conssepasol(self, constraints: Incomplete, nusefulconss: Incomplete, solution: Incomplete) -> Incomplete: ... def constrans(self, sourceconstraint: Incomplete) -> Incomplete: ... +@disjoint_base class Constant(GenExpr): number: Incomplete def __init__(self, *args, **kwargs) -> None: ... +@disjoint_base class Constraint: data: Incomplete name: Incomplete @@ -178,6 +188,7 @@ class Constraint: def __lt__(self, other: object) -> bool: ... def __ne__(self, other: object) -> bool: ... +@disjoint_base class Cutsel: model: Incomplete def __init__(self) -> None: ... @@ -188,10 +199,12 @@ class Cutsel: def cutselinitsol(self) -> Incomplete: ... def cutselselect(self, cuts: Incomplete, forcedcuts: Incomplete, root: Incomplete, maxnselectedcuts: Incomplete) -> Incomplete: ... +@disjoint_base class DomainChanges: def __init__(self) -> None: ... def getBoundchgs(self) -> Incomplete: ... +@disjoint_base class Event: data: Incomplete def __init__(self) -> None: ... @@ -211,6 +224,7 @@ class Event: def __lt__(self, other: object) -> bool: ... def __ne__(self, other: object) -> bool: ... +@disjoint_base class Eventhdlr: model: Incomplete name: Incomplete @@ -224,6 +238,7 @@ class Eventhdlr: def eventinit(self) -> Incomplete: ... def eventinitsol(self) -> Incomplete: ... +@disjoint_base class Expr: terms: Incomplete def __init__(self, *args, **kwargs) -> None: ... @@ -252,6 +267,7 @@ class Expr: def __sub__(self, other): ... def __truediv__(self, other): ... +@disjoint_base class ExprCons: _lhs: Incomplete _rhs: Incomplete @@ -266,6 +282,7 @@ class ExprCons: def __lt__(self, other: object) -> bool: ... def __ne__(self, other: object) -> bool: ... +@disjoint_base class GenExpr: _op: Incomplete children: Incomplete @@ -291,6 +308,7 @@ class GenExpr: def __sub__(self, other): ... def __truediv__(self, other): ... +@disjoint_base class Heur: model: Incomplete name: Incomplete @@ -302,6 +320,7 @@ class Heur: def heurinit(self) -> Incomplete: ... def heurinitsol(self) -> Incomplete: ... +@disjoint_base class IIS: def __init__(self) -> None: ... def getNNodes(self) -> Incomplete: ... @@ -313,12 +332,14 @@ class IIS: def setSubscipInfeasible(self, infeasible: Incomplete) -> Incomplete: ... def setSubscipIrreducible(self, irreducible: Incomplete) -> Incomplete: ... +@disjoint_base class IISfinder: iis: Incomplete def __init__(self) -> None: ... def iisfinderexec(self) -> Incomplete: ... def iisfinderfree(self) -> Incomplete: ... +@disjoint_base class LP: name: Incomplete def __init__(self, *args, **kwargs) -> None: ... @@ -415,6 +436,7 @@ class MatrixVariable(MatrixExpr): def varMayRound(self, direction: Incomplete = ...) -> Incomplete: ... def vtype(self) -> Incomplete: ... +@disjoint_base class Model: _freescip: Incomplete data: Incomplete @@ -841,6 +863,7 @@ class Model: def __lt__(self, other: object) -> bool: ... def __ne__(self, other: object) -> bool: ... +@disjoint_base class NLRow: data: Incomplete name: Incomplete @@ -858,6 +881,7 @@ class NLRow: def __lt__(self, other: object) -> bool: ... def __ne__(self, other: object) -> bool: ... +@disjoint_base class Node: data: Incomplete def __init__(self) -> None: ... @@ -883,6 +907,7 @@ class Node: def __lt__(self, other: object) -> bool: ... def __ne__(self, other: object) -> bool: ... +@disjoint_base class Nodesel: model: Incomplete def __init__(self) -> None: ... @@ -1168,10 +1193,12 @@ class PY_SCIP_STATUS: USERINTERRUPT: ClassVar[int] = ... def __init__(self) -> None: ... +@disjoint_base class PowExpr(GenExpr): expo: Incomplete def __init__(self, *args, **kwargs) -> None: ... +@disjoint_base class Presol: model: Incomplete def __init__(self) -> None: ... @@ -1182,6 +1209,7 @@ class Presol: def presolinit(self) -> Incomplete: ... def presolinitpre(self) -> Incomplete: ... +@disjoint_base class Pricer: model: Incomplete def __init__(self) -> None: ... @@ -1193,10 +1221,12 @@ class Pricer: def pricerinitsol(self) -> Incomplete: ... def pricerredcost(self) -> Incomplete: ... +@disjoint_base class ProdExpr(GenExpr): constant: Incomplete def __init__(self, *args, **kwargs) -> None: ... +@disjoint_base class Prop: model: Incomplete def __init__(self) -> None: ... @@ -1211,6 +1241,7 @@ class Prop: def proppresol(self, nrounds: Incomplete, presoltiming: Incomplete, result_dict: Incomplete) -> Incomplete: ... def propresprop(self, confvar: Incomplete, inferinfo: Incomplete, bdtype: Incomplete, relaxedbd: Incomplete) -> Incomplete: ... +@disjoint_base class Reader: model: Incomplete name: Incomplete @@ -1219,6 +1250,7 @@ class Reader: def readerread(self, filename: Incomplete) -> Incomplete: ... def readerwrite(self, file: Incomplete, name: Incomplete, transformed: Incomplete, objsense: Incomplete, objoffset: Incomplete, objscale: Incomplete, binvars: Incomplete, intvars: Incomplete, implvars: Incomplete, contvars: Incomplete, fixedvars: Incomplete, startnvars: Incomplete, conss: Incomplete, maxnconss: Incomplete, startnconss: Incomplete, genericnames: Incomplete) -> Incomplete: ... +@disjoint_base class Relax: model: Incomplete name: Incomplete @@ -1230,6 +1262,7 @@ class Relax: def relaxinit(self) -> Incomplete: ... def relaxinitsol(self) -> Incomplete: ... +@disjoint_base class Row: data: Incomplete name: Incomplete @@ -1262,10 +1295,12 @@ class Row: def __lt__(self, other: object) -> bool: ... def __ne__(self, other: object) -> bool: ... +@disjoint_base class RowExact: data: Incomplete def __init__(self) -> None: ... +@disjoint_base class Sepa: model: Incomplete name: Incomplete @@ -1278,6 +1313,7 @@ class Sepa: def sepainit(self) -> Incomplete: ... def sepainitsol(self) -> Incomplete: ... +@disjoint_base class Solution: data: Incomplete def __init__(self, *args, **kwargs) -> None: ... @@ -1337,6 +1373,7 @@ class Statistics: @property def n_vars(self): ... +@disjoint_base class SumExpr(GenExpr): coefs: Incomplete constant: Incomplete @@ -1356,10 +1393,12 @@ class Term: class UnaryExpr(GenExpr): def __init__(self, *args, **kwargs) -> None: ... +@disjoint_base class VarExpr(GenExpr): var: Incomplete def __init__(self, *args, **kwargs) -> None: ... +@disjoint_base class Variable(Expr): data: Incomplete name: Incomplete @@ -1397,5 +1436,6 @@ class Variable(Expr): def varMayRound(self, direction: Incomplete = ...) -> Incomplete: ... def vtype(self) -> Incomplete: ... +@disjoint_base class _VarArray: def __init__(self, *args, **kwargs) -> None: ... From 4546ff9c0c09e43efd2da8c1b064c427d11bf7b6 Mon Sep 17 00:00:00 2001 From: Jonathan Berthias Date: Mon, 29 Dec 2025 15:33:34 +0100 Subject: [PATCH 05/15] Fix Model.from_ptr --- src/pyscipopt/scip.pyi | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pyscipopt/scip.pyi b/src/pyscipopt/scip.pyi index 9649d226b..142cb3730 100644 --- a/src/pyscipopt/scip.pyi +++ b/src/pyscipopt/scip.pyi @@ -568,7 +568,7 @@ class Model: def freeSol(self, solution: Incomplete) -> Incomplete: ... def freeTransform(self) -> Incomplete: ... @staticmethod - def from_ptr(self, capsule: Incomplete, take_ownership: Incomplete = ...) -> Incomplete: ... + def from_ptr(capsule: Incomplete, take_ownership: Incomplete) -> Incomplete: ... def generateIIS(self) -> Incomplete: ... def getActivity(self, cons: Incomplete, sol: Incomplete = ...) -> Incomplete: ... def getBendersAuxiliaryVar(self, probnumber: Incomplete, benders: Incomplete = ...) -> Incomplete: ... From 273b129d06b21dcabbc844c03e5669c50f501c04 Mon Sep 17 00:00:00 2001 From: Jonathan Berthias Date: Mon, 29 Dec 2025 15:34:01 +0100 Subject: [PATCH 06/15] Remove _VarArray from stubs --- src/pyscipopt/scip.pyi | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/pyscipopt/scip.pyi b/src/pyscipopt/scip.pyi index 142cb3730..d4226c452 100644 --- a/src/pyscipopt/scip.pyi +++ b/src/pyscipopt/scip.pyi @@ -1435,7 +1435,3 @@ class Variable(Expr): def ptr(self) -> Incomplete: ... def varMayRound(self, direction: Incomplete = ...) -> Incomplete: ... def vtype(self) -> Incomplete: ... - -@disjoint_base -class _VarArray: - def __init__(self, *args, **kwargs) -> None: ... From c44cb74229197d7604dca405ae2a4f38488e888c Mon Sep 17 00:00:00 2001 From: Jonathan Berthias Date: Mon, 29 Dec 2025 15:34:27 +0100 Subject: [PATCH 07/15] Ignore errors on Statistics --- stubs/allowlist | 2 ++ 1 file changed, 2 insertions(+) diff --git a/stubs/allowlist b/stubs/allowlist index a9747c848..73a81d4d3 100644 --- a/stubs/allowlist +++ b/stubs/allowlist @@ -1,3 +1,5 @@ .*.__reduce_cython__ .*.__setstate_cython__ pyscipopt.scip.__test__ +pyscipopt.scip.Statistics.* +pyscipopt._version.__conditional_annotations__ From c4f8db0fee26f33cf5be953ff1da62c5b669b940 Mon Sep 17 00:00:00 2001 From: Jonathan Berthias Date: Mon, 29 Dec 2025 15:34:53 +0100 Subject: [PATCH 08/15] Update 'todo' allow list --- stubs/todo | 3677 ---------------------------------------------------- 1 file changed, 3677 deletions(-) diff --git a/stubs/todo b/stubs/todo index 81411bcf8..2eb7be13d 100644 --- a/stubs/todo +++ b/stubs/todo @@ -1,3680 +1,3 @@ -pyscipopt.Benders -pyscipopt.Benders.__init__ -pyscipopt.Benders.benderscreatesub -pyscipopt.Benders.bendersexit -pyscipopt.Benders.bendersexitpre -pyscipopt.Benders.bendersexitsol -pyscipopt.Benders.bendersfree -pyscipopt.Benders.bendersfreesub -pyscipopt.Benders.bendersgetvar -pyscipopt.Benders.bendersinit -pyscipopt.Benders.bendersinitpre -pyscipopt.Benders.bendersinitsol -pyscipopt.Benders.benderspostsolve -pyscipopt.Benders.benderspresubsolve -pyscipopt.Benders.benderssolvesub -pyscipopt.Benders.benderssolvesubconvex -pyscipopt.Benderscut -pyscipopt.Benderscut.__init__ -pyscipopt.Benderscut.benderscutexec -pyscipopt.Benderscut.benderscutexit -pyscipopt.Benderscut.benderscutexitsol -pyscipopt.Benderscut.benderscutfree -pyscipopt.Benderscut.benderscutinit -pyscipopt.Benderscut.benderscutinitsol -pyscipopt.Branchrule -pyscipopt.Branchrule.__init__ -pyscipopt.Branchrule.branchexecext -pyscipopt.Branchrule.branchexeclp -pyscipopt.Branchrule.branchexecps -pyscipopt.Branchrule.branchexit -pyscipopt.Branchrule.branchexitsol -pyscipopt.Branchrule.branchfree -pyscipopt.Branchrule.branchinit -pyscipopt.Branchrule.branchinitsol -pyscipopt.Conshdlr -pyscipopt.Conshdlr.__init__ -pyscipopt.Conshdlr.consactive -pyscipopt.Conshdlr.conscheck -pyscipopt.Conshdlr.conscopy -pyscipopt.Conshdlr.consdeactive -pyscipopt.Conshdlr.consdelete -pyscipopt.Conshdlr.consdelvars -pyscipopt.Conshdlr.consdisable -pyscipopt.Conshdlr.consenable -pyscipopt.Conshdlr.consenfolp -pyscipopt.Conshdlr.consenfops -pyscipopt.Conshdlr.consenforelax -pyscipopt.Conshdlr.consexit -pyscipopt.Conshdlr.consexitpre -pyscipopt.Conshdlr.consexitsol -pyscipopt.Conshdlr.consfree -pyscipopt.Conshdlr.consgetdivebdchgs -pyscipopt.Conshdlr.consgetnvars -pyscipopt.Conshdlr.consgetpermsymgraph -pyscipopt.Conshdlr.consgetsignedpermsymgraph -pyscipopt.Conshdlr.consgetvars -pyscipopt.Conshdlr.consinit -pyscipopt.Conshdlr.consinitlp -pyscipopt.Conshdlr.consinitpre -pyscipopt.Conshdlr.consinitsol -pyscipopt.Conshdlr.conslock -pyscipopt.Conshdlr.consparse -pyscipopt.Conshdlr.conspresol -pyscipopt.Conshdlr.consprint -pyscipopt.Conshdlr.consprop -pyscipopt.Conshdlr.consresprop -pyscipopt.Conshdlr.conssepalp -pyscipopt.Conshdlr.conssepasol -pyscipopt.Conshdlr.constrans -pyscipopt.Constraint -pyscipopt.Constraint.__init__ -pyscipopt.Constraint.getConshdlrName -pyscipopt.Constraint.isActive -pyscipopt.Constraint.isChecked -pyscipopt.Constraint.isDynamic -pyscipopt.Constraint.isEnforced -pyscipopt.Constraint.isInitial -pyscipopt.Constraint.isKnapsack -pyscipopt.Constraint.isLinear -pyscipopt.Constraint.isLinearType -pyscipopt.Constraint.isLocal -pyscipopt.Constraint.isModifiable -pyscipopt.Constraint.isNonlinear -pyscipopt.Constraint.isOriginal -pyscipopt.Constraint.isPropagated -pyscipopt.Constraint.isRemovable -pyscipopt.Constraint.isSeparated -pyscipopt.Constraint.isStickingAtNode -pyscipopt.Eventhdlr -pyscipopt.Eventhdlr.__init__ -pyscipopt.Eventhdlr.eventcopy -pyscipopt.Eventhdlr.eventdelete -pyscipopt.Eventhdlr.eventexec -pyscipopt.Eventhdlr.eventexit -pyscipopt.Eventhdlr.eventexitsol -pyscipopt.Eventhdlr.eventfree -pyscipopt.Eventhdlr.eventinit -pyscipopt.Eventhdlr.eventinitsol -pyscipopt.Expr -pyscipopt.Expr.__pow__ -pyscipopt.Expr.degree -pyscipopt.Expr.normalize -pyscipopt.ExprCons -pyscipopt.ExprCons.normalize -pyscipopt.Heur -pyscipopt.Heur.__init__ -pyscipopt.Heur.heurexec -pyscipopt.Heur.heurexit -pyscipopt.Heur.heurexitsol -pyscipopt.Heur.heurfree -pyscipopt.Heur.heurinit -pyscipopt.Heur.heurinitsol -pyscipopt.IISfinder -pyscipopt.IISfinder.__init__ -pyscipopt.IISfinder.iisfinderexec -pyscipopt.IISfinder.iisfinderfree -pyscipopt.LP -pyscipopt.LP.addCol -pyscipopt.LP.addCols -pyscipopt.LP.addRow -pyscipopt.LP.addRows -pyscipopt.LP.chgBound -pyscipopt.LP.chgCoef -pyscipopt.LP.chgObj -pyscipopt.LP.chgSide -pyscipopt.LP.clear -pyscipopt.LP.delCols -pyscipopt.LP.delRows -pyscipopt.LP.getActivity -pyscipopt.LP.getBasisInds -pyscipopt.LP.getBounds -pyscipopt.LP.getDual -pyscipopt.LP.getDualRay -pyscipopt.LP.getIntParam -pyscipopt.LP.getNIterations -pyscipopt.LP.getObjVal -pyscipopt.LP.getPrimal -pyscipopt.LP.getPrimalRay -pyscipopt.LP.getRealParam -pyscipopt.LP.getRedcost -pyscipopt.LP.getSides -pyscipopt.LP.infinity -pyscipopt.LP.isDualFeasible -pyscipopt.LP.isInfinity -pyscipopt.LP.isOptimal -pyscipopt.LP.isPrimalFeasible -pyscipopt.LP.ncols -pyscipopt.LP.nrows -pyscipopt.LP.readLP -pyscipopt.LP.setIntParam -pyscipopt.LP.setRealParam -pyscipopt.LP.solve -pyscipopt.LP.writeLP -pyscipopt.MatrixConstraint.getConshdlrName -pyscipopt.MatrixConstraint.isActive -pyscipopt.MatrixConstraint.isChecked -pyscipopt.MatrixConstraint.isDynamic -pyscipopt.MatrixConstraint.isEnforced -pyscipopt.MatrixConstraint.isInitial -pyscipopt.MatrixConstraint.isLinear -pyscipopt.MatrixConstraint.isLocal -pyscipopt.MatrixConstraint.isModifiable -pyscipopt.MatrixConstraint.isNonlinear -pyscipopt.MatrixConstraint.isPropagated -pyscipopt.MatrixConstraint.isRemovable -pyscipopt.MatrixConstraint.isSeparated -pyscipopt.MatrixConstraint.isStickingAtNode -pyscipopt.MatrixExpr.__matmul__ pyscipopt.MatrixExpr.sum -pyscipopt.MatrixVariable.getAvgSol -pyscipopt.MatrixVariable.getCol -pyscipopt.MatrixVariable.getIndex -pyscipopt.MatrixVariable.getLPSol -pyscipopt.MatrixVariable.getLbGlobal -pyscipopt.MatrixVariable.getLbLocal -pyscipopt.MatrixVariable.getLbOriginal -pyscipopt.MatrixVariable.getObj -pyscipopt.MatrixVariable.getUbGlobal -pyscipopt.MatrixVariable.getUbLocal -pyscipopt.MatrixVariable.getUbOriginal -pyscipopt.MatrixVariable.isInLP -pyscipopt.MatrixVariable.varMayRound -pyscipopt.MatrixVariable.vtype -pyscipopt.Model -pyscipopt.Model._createConsGenNonlinear -pyscipopt.Model._createConsLinear -pyscipopt.Model._createConsNonlinear -pyscipopt.Model._createConsQuadratic -pyscipopt.Model._getStageNames -pyscipopt.Model.activateBenders -pyscipopt.Model.addBendersSubproblem -pyscipopt.Model.addCoefKnapsack -pyscipopt.Model.addCoefLinear -pyscipopt.Model.addCons -pyscipopt.Model.addConsAnd -pyscipopt.Model.addConsCardinality -pyscipopt.Model.addConsCoeff -pyscipopt.Model.addConsDisjunction -pyscipopt.Model.addConsElemDisjunction -pyscipopt.Model.addConsIndicator -pyscipopt.Model.addConsKnapsack -pyscipopt.Model.addConsLocal -pyscipopt.Model.addConsNode -pyscipopt.Model.addConsOr -pyscipopt.Model.addConsSOS1 -pyscipopt.Model.addConsSOS2 -pyscipopt.Model.addConsXor -pyscipopt.Model.addConss -pyscipopt.Model.addCut -pyscipopt.Model.addExprNonlinear -pyscipopt.Model.addMatrixCons -pyscipopt.Model.addMatrixConsIndicator -pyscipopt.Model.addMatrixVar -pyscipopt.Model.addObjoffset -pyscipopt.Model.addPoolCut -pyscipopt.Model.addPyCons -pyscipopt.Model.addRowDive -pyscipopt.Model.addRowExact -pyscipopt.Model.addSol -pyscipopt.Model.addVar -pyscipopt.Model.addVarLocks -pyscipopt.Model.addVarLocksType -pyscipopt.Model.addVarSOS1 -pyscipopt.Model.addVarSOS2 -pyscipopt.Model.addVarToRow -pyscipopt.Model.allColsInLP -pyscipopt.Model.allowNegSlackExact -pyscipopt.Model.appendVarSOS1 -pyscipopt.Model.appendVarSOS2 -pyscipopt.Model.applyCutsProbing -pyscipopt.Model.attachEventHandlerCallback -pyscipopt.Model.backtrackProbing -pyscipopt.Model.branchLPExact -pyscipopt.Model.branchVar -pyscipopt.Model.branchVarVal -pyscipopt.Model.cacheRowExtensions -pyscipopt.Model.calcChildEstimate -pyscipopt.Model.calcNodeselPriority -pyscipopt.Model.catchEvent -pyscipopt.Model.catchRowEvent -pyscipopt.Model.catchVarEvent -pyscipopt.Model.checkBendersSubproblemOptimality -pyscipopt.Model.checkQuadraticNonlinear -pyscipopt.Model.checkSol -pyscipopt.Model.chgCapacityKnapsack -pyscipopt.Model.chgCoefLinear -pyscipopt.Model.chgLhs -pyscipopt.Model.chgReoptObjective -pyscipopt.Model.chgRhs -pyscipopt.Model.chgRowLhsDive -pyscipopt.Model.chgRowRhsDive -pyscipopt.Model.chgVarBranchPriority -pyscipopt.Model.chgVarLb -pyscipopt.Model.chgVarLbDive -pyscipopt.Model.chgVarLbGlobal -pyscipopt.Model.chgVarLbNode -pyscipopt.Model.chgVarLbProbing -pyscipopt.Model.chgVarObjDive -pyscipopt.Model.chgVarObjProbing -pyscipopt.Model.chgVarType -pyscipopt.Model.chgVarUb -pyscipopt.Model.chgVarUbDive -pyscipopt.Model.chgVarUbGlobal -pyscipopt.Model.chgVarUbNode -pyscipopt.Model.chgVarUbProbing -pyscipopt.Model.computeBestSolSubproblems -pyscipopt.Model.constructLP -pyscipopt.Model.copyLargeNeighborhoodSearch -pyscipopt.Model.count -pyscipopt.Model.createChild -pyscipopt.Model.createCons -pyscipopt.Model.createConsFromExpr -pyscipopt.Model.createEmptyRowSepa -pyscipopt.Model.createEmptyRowUnspec -pyscipopt.Model.createOrigSol -pyscipopt.Model.createPartialSol -pyscipopt.Model.createProbBasic -pyscipopt.Model.createSol -pyscipopt.Model.cutoffNode -pyscipopt.Model.deactivatePricer -pyscipopt.Model.delCoefLinear -pyscipopt.Model.delCons -pyscipopt.Model.delConsLocal -pyscipopt.Model.delVar -pyscipopt.Model.disableDebugSol -pyscipopt.Model.disablePropagation -pyscipopt.Model.dropEvent -pyscipopt.Model.dropRowEvent -pyscipopt.Model.dropVarEvent -pyscipopt.Model.enableDebugSol -pyscipopt.Model.enableExactSolving -pyscipopt.Model.enableReoptimization -pyscipopt.Model.endDive -pyscipopt.Model.endProbing -pyscipopt.Model.endStrongbranch -pyscipopt.Model.epsilon -pyscipopt.Model.feasCeil -pyscipopt.Model.feasFloor -pyscipopt.Model.feasFrac -pyscipopt.Model.feasRound -pyscipopt.Model.feastol -pyscipopt.Model.fixVar -pyscipopt.Model.fixVarProbing -pyscipopt.Model.flushRowExtensions -pyscipopt.Model.frac -pyscipopt.Model.freeBendersSubproblems -pyscipopt.Model.freeProb -pyscipopt.Model.freeReoptSolve -pyscipopt.Model.freeSol -pyscipopt.Model.freeTransform -pyscipopt.Model.from_ptr -pyscipopt.Model.generateIIS -pyscipopt.Model.getActivity -pyscipopt.Model.getBendersAuxiliaryVar -pyscipopt.Model.getBendersSubproblem -pyscipopt.Model.getBendersVar -pyscipopt.Model.getBestChild -pyscipopt.Model.getBestLeaf -pyscipopt.Model.getBestNode -pyscipopt.Model.getBestSibling -pyscipopt.Model.getBestSol -pyscipopt.Model.getBestboundNode -pyscipopt.Model.getBipartiteGraphRepresentation -pyscipopt.Model.getBranchScoreMultiple -pyscipopt.Model.getCapacityKnapsack -pyscipopt.Model.getChildren -pyscipopt.Model.getColRedCost -pyscipopt.Model.getCondition -pyscipopt.Model.getConsNVars -pyscipopt.Model.getConsVals -pyscipopt.Model.getConsVars -pyscipopt.Model.getConss -pyscipopt.Model.getCurrentNode -pyscipopt.Model.getCutEfficacy -pyscipopt.Model.getCutLPSolCutoffDistance -pyscipopt.Model.getCutoffbound -pyscipopt.Model.getDepth -pyscipopt.Model.getDualMultiplier -pyscipopt.Model.getDualSolVal -pyscipopt.Model.getDualbound -pyscipopt.Model.getDualboundRoot -pyscipopt.Model.getDualfarkasKnapsack -pyscipopt.Model.getDualfarkasLinear -pyscipopt.Model.getDualsolKnapsack -pyscipopt.Model.getDualsolLinear -pyscipopt.Model.getGap -pyscipopt.Model.getHeurTiming -pyscipopt.Model.getIIS -pyscipopt.Model.getLPBInvARow -pyscipopt.Model.getLPBInvRow -pyscipopt.Model.getLPBasisInd -pyscipopt.Model.getLPBranchCands -pyscipopt.Model.getLPColsData -pyscipopt.Model.getLPObjVal -pyscipopt.Model.getLPRowsData -pyscipopt.Model.getLPSolstat -pyscipopt.Model.getLeaves -pyscipopt.Model.getLhs -pyscipopt.Model.getLinearConsIndicator -pyscipopt.Model.getLocalEstimate -pyscipopt.Model.getLowerbound -pyscipopt.Model.getMajorVersion -pyscipopt.Model.getMaxDepth -pyscipopt.Model.getMinorVersion -pyscipopt.Model.getNBestSolsFound -pyscipopt.Model.getNBinVars -pyscipopt.Model.getNChildren -pyscipopt.Model.getNConss -pyscipopt.Model.getNContVars -pyscipopt.Model.getNCountedSols -pyscipopt.Model.getNCuts -pyscipopt.Model.getNCutsApplied -pyscipopt.Model.getNFeasibleLeaves -pyscipopt.Model.getNImplVars -pyscipopt.Model.getNInfeasibleLeaves -pyscipopt.Model.getNIntVars -pyscipopt.Model.getNLPBranchCands -pyscipopt.Model.getNLPCols -pyscipopt.Model.getNLPIterations -pyscipopt.Model.getNLPRows -pyscipopt.Model.getNLPs -pyscipopt.Model.getNLeaves -pyscipopt.Model.getNLimSolsFound -pyscipopt.Model.getNNlRows -pyscipopt.Model.getNNodeLPIterations -pyscipopt.Model.getNNodes -pyscipopt.Model.getNReaders -pyscipopt.Model.getNSepaRounds -pyscipopt.Model.getNSiblings -pyscipopt.Model.getNSols -pyscipopt.Model.getNSolsFound -pyscipopt.Model.getNStrongbranchLPIterations -pyscipopt.Model.getNTotalNodes -pyscipopt.Model.getNVars -pyscipopt.Model.getNVarsAnd -pyscipopt.Model.getNlRowActivityBounds -pyscipopt.Model.getNlRowSolActivity -pyscipopt.Model.getNlRowSolFeasibility -pyscipopt.Model.getNlRows -pyscipopt.Model.getObjVal -pyscipopt.Model.getObjective -pyscipopt.Model.getObjectiveSense -pyscipopt.Model.getObjlimit -pyscipopt.Model.getObjoffset -pyscipopt.Model.getOpenNodes -pyscipopt.Model.getParam -pyscipopt.Model.getParams -pyscipopt.Model.getPlungeDepth -pyscipopt.Model.getPresolvingTime -pyscipopt.Model.getPrimalRay -pyscipopt.Model.getPrimalRayVal -pyscipopt.Model.getPrimalbound -pyscipopt.Model.getPrioChild -pyscipopt.Model.getPrioSibling -pyscipopt.Model.getProbName -pyscipopt.Model.getProbingDepth -pyscipopt.Model.getPseudoBranchCands -pyscipopt.Model.getReadingTime -pyscipopt.Model.getResultantAnd -pyscipopt.Model.getRhs -pyscipopt.Model.getRowActivity -pyscipopt.Model.getRowDualSol -pyscipopt.Model.getRowLPActivity -pyscipopt.Model.getRowLinear -pyscipopt.Model.getRowNumIntCols -pyscipopt.Model.getRowObjParallelism -pyscipopt.Model.getRowParallelism -pyscipopt.Model.getSiblings -pyscipopt.Model.getSlack -pyscipopt.Model.getSlackVarIndicator -pyscipopt.Model.getSolObjVal -pyscipopt.Model.getSolTime -pyscipopt.Model.getSolVal -pyscipopt.Model.getSols -pyscipopt.Model.getSolvingTime -pyscipopt.Model.getStage -pyscipopt.Model.getStageName -pyscipopt.Model.getStatus -pyscipopt.Model.getTechVersion -pyscipopt.Model.getTermsQuadratic -pyscipopt.Model.getTotalTime -pyscipopt.Model.getTransformedCons -pyscipopt.Model.getTransformedVar -pyscipopt.Model.getTreesizeEstimation -pyscipopt.Model.getVal -pyscipopt.Model.getValsLinear -pyscipopt.Model.getVarDict -pyscipopt.Model.getVarLbDive -pyscipopt.Model.getVarPseudocost -pyscipopt.Model.getVarPseudocostScore -pyscipopt.Model.getVarRedcost -pyscipopt.Model.getVarStrongbranch -pyscipopt.Model.getVarStrongbranchLast -pyscipopt.Model.getVarStrongbranchNode -pyscipopt.Model.getVarUbDive -pyscipopt.Model.getVars -pyscipopt.Model.getVarsAnd -pyscipopt.Model.getWeightsKnapsack -pyscipopt.Model.hasPrimalRay -pyscipopt.Model.hideOutput -pyscipopt.Model.inProbing -pyscipopt.Model.inRepropagation -pyscipopt.Model.includeBenders -pyscipopt.Model.includeBendersDefaultCuts -pyscipopt.Model.includeBenderscut -pyscipopt.Model.includeBranchrule -pyscipopt.Model.includeConshdlr -pyscipopt.Model.includeCutsel -pyscipopt.Model.includeDefaultPlugins -pyscipopt.Model.includeEventhdlr -pyscipopt.Model.includeHeur -pyscipopt.Model.includeIISfinder -pyscipopt.Model.includeNodesel -pyscipopt.Model.includePresol -pyscipopt.Model.includePricer -pyscipopt.Model.includeProp -pyscipopt.Model.includeReader -pyscipopt.Model.includeRelax -pyscipopt.Model.includeSepa -pyscipopt.Model.infinity -pyscipopt.Model.initBendersDefault -pyscipopt.Model.interruptSolve -pyscipopt.Model.isAndConsSorted -pyscipopt.Model.isCutEfficacious -pyscipopt.Model.isEQ -pyscipopt.Model.isExact -pyscipopt.Model.isFeasEQ -pyscipopt.Model.isFeasGE -pyscipopt.Model.isFeasGT -pyscipopt.Model.isFeasIntegral -pyscipopt.Model.isFeasLE -pyscipopt.Model.isFeasLT -pyscipopt.Model.isFeasNegative -pyscipopt.Model.isFeasPositive -pyscipopt.Model.isFeasZero -pyscipopt.Model.isGE -pyscipopt.Model.isGT -pyscipopt.Model.isHugeValue -pyscipopt.Model.isInfinity -pyscipopt.Model.isLE -pyscipopt.Model.isLPSolBasic -pyscipopt.Model.isLT -pyscipopt.Model.isNLPConstructed -pyscipopt.Model.isNegative -pyscipopt.Model.isObjChangedProbing -pyscipopt.Model.isPositive -pyscipopt.Model.isZero -pyscipopt.Model.lpiGetIterations -pyscipopt.Model.markDoNotAggrVar -pyscipopt.Model.markDoNotMultaggrVar -pyscipopt.Model.newProbingNode -pyscipopt.Model.optimize -pyscipopt.Model.optimizeNogil -pyscipopt.Model.presolve -pyscipopt.Model.printBestSol -pyscipopt.Model.printCons -pyscipopt.Model.printExternalCodeVersions -pyscipopt.Model.printNlRow -pyscipopt.Model.printProblem -pyscipopt.Model.printRow -pyscipopt.Model.printSol -pyscipopt.Model.printStatistics -pyscipopt.Model.printStatisticsJson -pyscipopt.Model.printVersion -pyscipopt.Model.propagateProbing -pyscipopt.Model.readParams -pyscipopt.Model.readProblem -pyscipopt.Model.readSol -pyscipopt.Model.readSolFile -pyscipopt.Model.redirectOutput -pyscipopt.Model.relax -pyscipopt.Model.releaseRow -pyscipopt.Model.repropagateNode -pyscipopt.Model.resetParam -pyscipopt.Model.resetParams -pyscipopt.Model.restartSolve -pyscipopt.Model.separateSol -pyscipopt.Model.setBendersSubproblemIsConvex -pyscipopt.Model.setBoolParam -pyscipopt.Model.setCharParam -pyscipopt.Model.setCheck -pyscipopt.Model.setEmphasis -pyscipopt.Model.setEnforced -pyscipopt.Model.setHeurTiming -pyscipopt.Model.setHeuristics -pyscipopt.Model.setInitial -pyscipopt.Model.setIntParam -pyscipopt.Model.setLogfile -pyscipopt.Model.setLongintParam -pyscipopt.Model.setMaximize -pyscipopt.Model.setMinimize -pyscipopt.Model.setModifiable -pyscipopt.Model.setObjIntegral -pyscipopt.Model.setObjective -pyscipopt.Model.setObjlimit -pyscipopt.Model.setParam -pyscipopt.Model.setParams -pyscipopt.Model.setParamsCountsols -pyscipopt.Model.setPresolve -pyscipopt.Model.setProbName -pyscipopt.Model.setRealParam -pyscipopt.Model.setRelaxSolVal -pyscipopt.Model.setRemovable -pyscipopt.Model.setSeparating -pyscipopt.Model.setSolVal -pyscipopt.Model.setStringParam -pyscipopt.Model.setupBendersSubproblem -pyscipopt.Model.solveBendersSubproblem -pyscipopt.Model.solveConcurrent -pyscipopt.Model.solveDiveLP -pyscipopt.Model.solveProbingLP -pyscipopt.Model.sortAndCons -pyscipopt.Model.startDive -pyscipopt.Model.startProbing -pyscipopt.Model.startStrongbranch -pyscipopt.Model.tightenVarLb -pyscipopt.Model.tightenVarLbGlobal -pyscipopt.Model.tightenVarUb -pyscipopt.Model.tightenVarUbGlobal -pyscipopt.Model.to_ptr -pyscipopt.Model.translateSubSol -pyscipopt.Model.trySol -pyscipopt.Model.updateBendersLowerbounds -pyscipopt.Model.updateNodeLowerbound -pyscipopt.Model.updateVarPseudocost -pyscipopt.Model.version -pyscipopt.Model.writeBestSol -pyscipopt.Model.writeBestTransSol -pyscipopt.Model.writeLP -pyscipopt.Model.writeMIP -pyscipopt.Model.writeName -pyscipopt.Model.writeParams -pyscipopt.Model.writeProblem -pyscipopt.Model.writeSol -pyscipopt.Model.writeStatistics -pyscipopt.Model.writeStatisticsJson -pyscipopt.Model.writeTransSol -pyscipopt.Nodesel -pyscipopt.Nodesel.__init__ -pyscipopt.Nodesel.nodecomp -pyscipopt.Nodesel.nodeexit -pyscipopt.Nodesel.nodeexitsol -pyscipopt.Nodesel.nodefree -pyscipopt.Nodesel.nodeinit -pyscipopt.Nodesel.nodeinitsol -pyscipopt.Nodesel.nodeselect -pyscipopt.Presol -pyscipopt.Presol.__init__ -pyscipopt.Presol.presolexec -pyscipopt.Presol.presolexit -pyscipopt.Presol.presolexitpre -pyscipopt.Presol.presolfree -pyscipopt.Presol.presolinit -pyscipopt.Presol.presolinitpre -pyscipopt.Pricer -pyscipopt.Pricer.__init__ -pyscipopt.Pricer.pricerexit -pyscipopt.Pricer.pricerexitsol -pyscipopt.Pricer.pricerfarkas -pyscipopt.Pricer.pricerfree -pyscipopt.Pricer.pricerinit -pyscipopt.Pricer.pricerinitsol -pyscipopt.Pricer.pricerredcost -pyscipopt.Prop -pyscipopt.Prop.__init__ -pyscipopt.Prop.propexec -pyscipopt.Prop.propexit -pyscipopt.Prop.propexitpre -pyscipopt.Prop.propexitsol -pyscipopt.Prop.propfree -pyscipopt.Prop.propinit -pyscipopt.Prop.propinitpre -pyscipopt.Prop.propinitsol -pyscipopt.Prop.proppresol -pyscipopt.Prop.propresprop -pyscipopt.Reader -pyscipopt.Reader.__init__ -pyscipopt.Reader.readerfree -pyscipopt.Reader.readerread -pyscipopt.Reader.readerwrite -pyscipopt.SCIP_BENDERSENFOTYPE.__init__ -pyscipopt.SCIP_BRANCHDIR.__init__ -pyscipopt.SCIP_EVENTTYPE.__init__ -pyscipopt.SCIP_HEURTIMING.__init__ -pyscipopt.SCIP_IMPLINTTYPE.__init__ -pyscipopt.SCIP_LOCKTYPE.__init__ -pyscipopt.SCIP_LPPARAM.__init__ -pyscipopt.SCIP_LPSOLSTAT.__init__ -pyscipopt.SCIP_NODETYPE.__init__ -pyscipopt.SCIP_PARAMEMPHASIS.__init__ -pyscipopt.SCIP_PARAMSETTING.__init__ -pyscipopt.SCIP_PRESOLTIMING.__init__ -pyscipopt.SCIP_PROPTIMING.__init__ -pyscipopt.SCIP_RESULT.__init__ -pyscipopt.SCIP_ROWORIGINTYPE.__init__ -pyscipopt.SCIP_SOLORIGIN.__init__ -pyscipopt.SCIP_STAGE.__init__ -pyscipopt.SCIP_STATUS.__init__ -pyscipopt.Sepa -pyscipopt.Sepa.__init__ -pyscipopt.Sepa.sepaexeclp -pyscipopt.Sepa.sepaexecsol -pyscipopt.Sepa.sepaexit -pyscipopt.Sepa.sepaexitsol -pyscipopt.Sepa.sepafree -pyscipopt.Sepa.sepainit -pyscipopt.Sepa.sepainitsol -pyscipopt.Variable -pyscipopt.Variable.getAvgSol -pyscipopt.Variable.getCol -pyscipopt.Variable.getImplType -pyscipopt.Variable.getIndex -pyscipopt.Variable.getLPSol -pyscipopt.Variable.getLbGlobal -pyscipopt.Variable.getLbLocal -pyscipopt.Variable.getLbOriginal -pyscipopt.Variable.getNBranchings -pyscipopt.Variable.getNBranchingsCurrentRun -pyscipopt.Variable.getNLocksDown -pyscipopt.Variable.getNLocksDownType -pyscipopt.Variable.getNLocksUp -pyscipopt.Variable.getNLocksUpType -pyscipopt.Variable.getObj -pyscipopt.Variable.getStatus -pyscipopt.Variable.getUbGlobal -pyscipopt.Variable.getUbLocal -pyscipopt.Variable.getUbOriginal -pyscipopt.Variable.isActive -pyscipopt.Variable.isBinary -pyscipopt.Variable.isDeletable -pyscipopt.Variable.isImpliedIntegral -pyscipopt.Variable.isInLP -pyscipopt.Variable.isIntegral -pyscipopt.Variable.isNonImpliedIntegral -pyscipopt.Variable.isOriginal -pyscipopt.Variable.isRelaxationOnly -pyscipopt.Variable.markRelaxationOnly -pyscipopt.Variable.ptr -pyscipopt.Variable.varMayRound -pyscipopt.Variable.vtype -pyscipopt._version.__conditional_annotations__ -pyscipopt.recipes.getLocalConss.Constraint -pyscipopt.recipes.getLocalConss.Constraint.__init__ -pyscipopt.recipes.getLocalConss.Constraint.getConshdlrName -pyscipopt.recipes.getLocalConss.Constraint.isActive -pyscipopt.recipes.getLocalConss.Constraint.isChecked -pyscipopt.recipes.getLocalConss.Constraint.isDynamic -pyscipopt.recipes.getLocalConss.Constraint.isEnforced -pyscipopt.recipes.getLocalConss.Constraint.isInitial -pyscipopt.recipes.getLocalConss.Constraint.isKnapsack -pyscipopt.recipes.getLocalConss.Constraint.isLinear -pyscipopt.recipes.getLocalConss.Constraint.isLinearType -pyscipopt.recipes.getLocalConss.Constraint.isLocal -pyscipopt.recipes.getLocalConss.Constraint.isModifiable -pyscipopt.recipes.getLocalConss.Constraint.isNonlinear -pyscipopt.recipes.getLocalConss.Constraint.isOriginal -pyscipopt.recipes.getLocalConss.Constraint.isPropagated -pyscipopt.recipes.getLocalConss.Constraint.isRemovable -pyscipopt.recipes.getLocalConss.Constraint.isSeparated -pyscipopt.recipes.getLocalConss.Constraint.isStickingAtNode -pyscipopt.recipes.getLocalConss.Model -pyscipopt.recipes.getLocalConss.Model._createConsGenNonlinear -pyscipopt.recipes.getLocalConss.Model._createConsLinear -pyscipopt.recipes.getLocalConss.Model._createConsNonlinear -pyscipopt.recipes.getLocalConss.Model._createConsQuadratic -pyscipopt.recipes.getLocalConss.Model._getStageNames -pyscipopt.recipes.getLocalConss.Model.activateBenders -pyscipopt.recipes.getLocalConss.Model.addBendersSubproblem -pyscipopt.recipes.getLocalConss.Model.addCoefKnapsack -pyscipopt.recipes.getLocalConss.Model.addCoefLinear -pyscipopt.recipes.getLocalConss.Model.addCons -pyscipopt.recipes.getLocalConss.Model.addConsAnd -pyscipopt.recipes.getLocalConss.Model.addConsCardinality -pyscipopt.recipes.getLocalConss.Model.addConsCoeff -pyscipopt.recipes.getLocalConss.Model.addConsDisjunction -pyscipopt.recipes.getLocalConss.Model.addConsElemDisjunction -pyscipopt.recipes.getLocalConss.Model.addConsIndicator -pyscipopt.recipes.getLocalConss.Model.addConsKnapsack -pyscipopt.recipes.getLocalConss.Model.addConsLocal -pyscipopt.recipes.getLocalConss.Model.addConsNode -pyscipopt.recipes.getLocalConss.Model.addConsOr -pyscipopt.recipes.getLocalConss.Model.addConsSOS1 -pyscipopt.recipes.getLocalConss.Model.addConsSOS2 -pyscipopt.recipes.getLocalConss.Model.addConsXor -pyscipopt.recipes.getLocalConss.Model.addConss -pyscipopt.recipes.getLocalConss.Model.addCut -pyscipopt.recipes.getLocalConss.Model.addExprNonlinear -pyscipopt.recipes.getLocalConss.Model.addMatrixCons -pyscipopt.recipes.getLocalConss.Model.addMatrixConsIndicator -pyscipopt.recipes.getLocalConss.Model.addMatrixVar -pyscipopt.recipes.getLocalConss.Model.addObjoffset -pyscipopt.recipes.getLocalConss.Model.addPoolCut -pyscipopt.recipes.getLocalConss.Model.addPyCons -pyscipopt.recipes.getLocalConss.Model.addRowDive -pyscipopt.recipes.getLocalConss.Model.addRowExact -pyscipopt.recipes.getLocalConss.Model.addSol -pyscipopt.recipes.getLocalConss.Model.addVar -pyscipopt.recipes.getLocalConss.Model.addVarLocks -pyscipopt.recipes.getLocalConss.Model.addVarLocksType -pyscipopt.recipes.getLocalConss.Model.addVarSOS1 -pyscipopt.recipes.getLocalConss.Model.addVarSOS2 -pyscipopt.recipes.getLocalConss.Model.addVarToRow -pyscipopt.recipes.getLocalConss.Model.allColsInLP -pyscipopt.recipes.getLocalConss.Model.allowNegSlackExact -pyscipopt.recipes.getLocalConss.Model.appendVarSOS1 -pyscipopt.recipes.getLocalConss.Model.appendVarSOS2 -pyscipopt.recipes.getLocalConss.Model.applyCutsProbing -pyscipopt.recipes.getLocalConss.Model.attachEventHandlerCallback -pyscipopt.recipes.getLocalConss.Model.backtrackProbing -pyscipopt.recipes.getLocalConss.Model.branchLPExact -pyscipopt.recipes.getLocalConss.Model.branchVar -pyscipopt.recipes.getLocalConss.Model.branchVarVal -pyscipopt.recipes.getLocalConss.Model.cacheRowExtensions -pyscipopt.recipes.getLocalConss.Model.calcChildEstimate -pyscipopt.recipes.getLocalConss.Model.calcNodeselPriority -pyscipopt.recipes.getLocalConss.Model.catchEvent -pyscipopt.recipes.getLocalConss.Model.catchRowEvent -pyscipopt.recipes.getLocalConss.Model.catchVarEvent -pyscipopt.recipes.getLocalConss.Model.checkBendersSubproblemOptimality -pyscipopt.recipes.getLocalConss.Model.checkQuadraticNonlinear -pyscipopt.recipes.getLocalConss.Model.checkSol -pyscipopt.recipes.getLocalConss.Model.chgCapacityKnapsack -pyscipopt.recipes.getLocalConss.Model.chgCoefLinear -pyscipopt.recipes.getLocalConss.Model.chgLhs -pyscipopt.recipes.getLocalConss.Model.chgReoptObjective -pyscipopt.recipes.getLocalConss.Model.chgRhs -pyscipopt.recipes.getLocalConss.Model.chgRowLhsDive -pyscipopt.recipes.getLocalConss.Model.chgRowRhsDive -pyscipopt.recipes.getLocalConss.Model.chgVarBranchPriority -pyscipopt.recipes.getLocalConss.Model.chgVarLb -pyscipopt.recipes.getLocalConss.Model.chgVarLbDive -pyscipopt.recipes.getLocalConss.Model.chgVarLbGlobal -pyscipopt.recipes.getLocalConss.Model.chgVarLbNode -pyscipopt.recipes.getLocalConss.Model.chgVarLbProbing -pyscipopt.recipes.getLocalConss.Model.chgVarObjDive -pyscipopt.recipes.getLocalConss.Model.chgVarObjProbing -pyscipopt.recipes.getLocalConss.Model.chgVarType -pyscipopt.recipes.getLocalConss.Model.chgVarUb -pyscipopt.recipes.getLocalConss.Model.chgVarUbDive -pyscipopt.recipes.getLocalConss.Model.chgVarUbGlobal -pyscipopt.recipes.getLocalConss.Model.chgVarUbNode -pyscipopt.recipes.getLocalConss.Model.chgVarUbProbing -pyscipopt.recipes.getLocalConss.Model.computeBestSolSubproblems -pyscipopt.recipes.getLocalConss.Model.constructLP -pyscipopt.recipes.getLocalConss.Model.copyLargeNeighborhoodSearch -pyscipopt.recipes.getLocalConss.Model.count -pyscipopt.recipes.getLocalConss.Model.createChild -pyscipopt.recipes.getLocalConss.Model.createCons -pyscipopt.recipes.getLocalConss.Model.createConsFromExpr -pyscipopt.recipes.getLocalConss.Model.createEmptyRowSepa -pyscipopt.recipes.getLocalConss.Model.createEmptyRowUnspec -pyscipopt.recipes.getLocalConss.Model.createOrigSol -pyscipopt.recipes.getLocalConss.Model.createPartialSol -pyscipopt.recipes.getLocalConss.Model.createProbBasic -pyscipopt.recipes.getLocalConss.Model.createSol -pyscipopt.recipes.getLocalConss.Model.cutoffNode -pyscipopt.recipes.getLocalConss.Model.deactivatePricer -pyscipopt.recipes.getLocalConss.Model.delCoefLinear -pyscipopt.recipes.getLocalConss.Model.delCons -pyscipopt.recipes.getLocalConss.Model.delConsLocal -pyscipopt.recipes.getLocalConss.Model.delVar -pyscipopt.recipes.getLocalConss.Model.disableDebugSol -pyscipopt.recipes.getLocalConss.Model.disablePropagation -pyscipopt.recipes.getLocalConss.Model.dropEvent -pyscipopt.recipes.getLocalConss.Model.dropRowEvent -pyscipopt.recipes.getLocalConss.Model.dropVarEvent -pyscipopt.recipes.getLocalConss.Model.enableDebugSol -pyscipopt.recipes.getLocalConss.Model.enableExactSolving -pyscipopt.recipes.getLocalConss.Model.enableReoptimization -pyscipopt.recipes.getLocalConss.Model.endDive -pyscipopt.recipes.getLocalConss.Model.endProbing -pyscipopt.recipes.getLocalConss.Model.endStrongbranch -pyscipopt.recipes.getLocalConss.Model.epsilon -pyscipopt.recipes.getLocalConss.Model.feasCeil -pyscipopt.recipes.getLocalConss.Model.feasFloor -pyscipopt.recipes.getLocalConss.Model.feasFrac -pyscipopt.recipes.getLocalConss.Model.feasRound -pyscipopt.recipes.getLocalConss.Model.feastol -pyscipopt.recipes.getLocalConss.Model.fixVar -pyscipopt.recipes.getLocalConss.Model.fixVarProbing -pyscipopt.recipes.getLocalConss.Model.flushRowExtensions -pyscipopt.recipes.getLocalConss.Model.frac -pyscipopt.recipes.getLocalConss.Model.freeBendersSubproblems -pyscipopt.recipes.getLocalConss.Model.freeProb -pyscipopt.recipes.getLocalConss.Model.freeReoptSolve -pyscipopt.recipes.getLocalConss.Model.freeSol -pyscipopt.recipes.getLocalConss.Model.freeTransform -pyscipopt.recipes.getLocalConss.Model.from_ptr -pyscipopt.recipes.getLocalConss.Model.generateIIS -pyscipopt.recipes.getLocalConss.Model.getActivity -pyscipopt.recipes.getLocalConss.Model.getBendersAuxiliaryVar -pyscipopt.recipes.getLocalConss.Model.getBendersSubproblem -pyscipopt.recipes.getLocalConss.Model.getBendersVar -pyscipopt.recipes.getLocalConss.Model.getBestChild -pyscipopt.recipes.getLocalConss.Model.getBestLeaf -pyscipopt.recipes.getLocalConss.Model.getBestNode -pyscipopt.recipes.getLocalConss.Model.getBestSibling -pyscipopt.recipes.getLocalConss.Model.getBestSol -pyscipopt.recipes.getLocalConss.Model.getBestboundNode -pyscipopt.recipes.getLocalConss.Model.getBipartiteGraphRepresentation -pyscipopt.recipes.getLocalConss.Model.getBranchScoreMultiple -pyscipopt.recipes.getLocalConss.Model.getCapacityKnapsack -pyscipopt.recipes.getLocalConss.Model.getChildren -pyscipopt.recipes.getLocalConss.Model.getColRedCost -pyscipopt.recipes.getLocalConss.Model.getCondition -pyscipopt.recipes.getLocalConss.Model.getConsNVars -pyscipopt.recipes.getLocalConss.Model.getConsVals -pyscipopt.recipes.getLocalConss.Model.getConsVars -pyscipopt.recipes.getLocalConss.Model.getConss -pyscipopt.recipes.getLocalConss.Model.getCurrentNode -pyscipopt.recipes.getLocalConss.Model.getCutEfficacy -pyscipopt.recipes.getLocalConss.Model.getCutLPSolCutoffDistance -pyscipopt.recipes.getLocalConss.Model.getCutoffbound -pyscipopt.recipes.getLocalConss.Model.getDepth -pyscipopt.recipes.getLocalConss.Model.getDualMultiplier -pyscipopt.recipes.getLocalConss.Model.getDualSolVal -pyscipopt.recipes.getLocalConss.Model.getDualbound -pyscipopt.recipes.getLocalConss.Model.getDualboundRoot -pyscipopt.recipes.getLocalConss.Model.getDualfarkasKnapsack -pyscipopt.recipes.getLocalConss.Model.getDualfarkasLinear -pyscipopt.recipes.getLocalConss.Model.getDualsolKnapsack -pyscipopt.recipes.getLocalConss.Model.getDualsolLinear -pyscipopt.recipes.getLocalConss.Model.getGap -pyscipopt.recipes.getLocalConss.Model.getHeurTiming -pyscipopt.recipes.getLocalConss.Model.getIIS -pyscipopt.recipes.getLocalConss.Model.getLPBInvARow -pyscipopt.recipes.getLocalConss.Model.getLPBInvRow -pyscipopt.recipes.getLocalConss.Model.getLPBasisInd -pyscipopt.recipes.getLocalConss.Model.getLPBranchCands -pyscipopt.recipes.getLocalConss.Model.getLPColsData -pyscipopt.recipes.getLocalConss.Model.getLPObjVal -pyscipopt.recipes.getLocalConss.Model.getLPRowsData -pyscipopt.recipes.getLocalConss.Model.getLPSolstat -pyscipopt.recipes.getLocalConss.Model.getLeaves -pyscipopt.recipes.getLocalConss.Model.getLhs -pyscipopt.recipes.getLocalConss.Model.getLinearConsIndicator -pyscipopt.recipes.getLocalConss.Model.getLocalEstimate -pyscipopt.recipes.getLocalConss.Model.getLowerbound -pyscipopt.recipes.getLocalConss.Model.getMajorVersion -pyscipopt.recipes.getLocalConss.Model.getMaxDepth -pyscipopt.recipes.getLocalConss.Model.getMinorVersion -pyscipopt.recipes.getLocalConss.Model.getNBestSolsFound -pyscipopt.recipes.getLocalConss.Model.getNBinVars -pyscipopt.recipes.getLocalConss.Model.getNChildren -pyscipopt.recipes.getLocalConss.Model.getNConss -pyscipopt.recipes.getLocalConss.Model.getNContVars -pyscipopt.recipes.getLocalConss.Model.getNCountedSols -pyscipopt.recipes.getLocalConss.Model.getNCuts -pyscipopt.recipes.getLocalConss.Model.getNCutsApplied -pyscipopt.recipes.getLocalConss.Model.getNFeasibleLeaves -pyscipopt.recipes.getLocalConss.Model.getNImplVars -pyscipopt.recipes.getLocalConss.Model.getNInfeasibleLeaves -pyscipopt.recipes.getLocalConss.Model.getNIntVars -pyscipopt.recipes.getLocalConss.Model.getNLPBranchCands -pyscipopt.recipes.getLocalConss.Model.getNLPCols -pyscipopt.recipes.getLocalConss.Model.getNLPIterations -pyscipopt.recipes.getLocalConss.Model.getNLPRows -pyscipopt.recipes.getLocalConss.Model.getNLPs -pyscipopt.recipes.getLocalConss.Model.getNLeaves -pyscipopt.recipes.getLocalConss.Model.getNLimSolsFound -pyscipopt.recipes.getLocalConss.Model.getNNlRows -pyscipopt.recipes.getLocalConss.Model.getNNodeLPIterations -pyscipopt.recipes.getLocalConss.Model.getNNodes -pyscipopt.recipes.getLocalConss.Model.getNReaders -pyscipopt.recipes.getLocalConss.Model.getNSepaRounds -pyscipopt.recipes.getLocalConss.Model.getNSiblings -pyscipopt.recipes.getLocalConss.Model.getNSols -pyscipopt.recipes.getLocalConss.Model.getNSolsFound -pyscipopt.recipes.getLocalConss.Model.getNStrongbranchLPIterations -pyscipopt.recipes.getLocalConss.Model.getNTotalNodes -pyscipopt.recipes.getLocalConss.Model.getNVars -pyscipopt.recipes.getLocalConss.Model.getNVarsAnd -pyscipopt.recipes.getLocalConss.Model.getNlRowActivityBounds -pyscipopt.recipes.getLocalConss.Model.getNlRowSolActivity -pyscipopt.recipes.getLocalConss.Model.getNlRowSolFeasibility -pyscipopt.recipes.getLocalConss.Model.getNlRows -pyscipopt.recipes.getLocalConss.Model.getObjVal -pyscipopt.recipes.getLocalConss.Model.getObjective -pyscipopt.recipes.getLocalConss.Model.getObjectiveSense -pyscipopt.recipes.getLocalConss.Model.getObjlimit -pyscipopt.recipes.getLocalConss.Model.getObjoffset -pyscipopt.recipes.getLocalConss.Model.getOpenNodes -pyscipopt.recipes.getLocalConss.Model.getParam -pyscipopt.recipes.getLocalConss.Model.getParams -pyscipopt.recipes.getLocalConss.Model.getPlungeDepth -pyscipopt.recipes.getLocalConss.Model.getPresolvingTime -pyscipopt.recipes.getLocalConss.Model.getPrimalRay -pyscipopt.recipes.getLocalConss.Model.getPrimalRayVal -pyscipopt.recipes.getLocalConss.Model.getPrimalbound -pyscipopt.recipes.getLocalConss.Model.getPrioChild -pyscipopt.recipes.getLocalConss.Model.getPrioSibling -pyscipopt.recipes.getLocalConss.Model.getProbName -pyscipopt.recipes.getLocalConss.Model.getProbingDepth -pyscipopt.recipes.getLocalConss.Model.getPseudoBranchCands -pyscipopt.recipes.getLocalConss.Model.getReadingTime -pyscipopt.recipes.getLocalConss.Model.getResultantAnd -pyscipopt.recipes.getLocalConss.Model.getRhs -pyscipopt.recipes.getLocalConss.Model.getRowActivity -pyscipopt.recipes.getLocalConss.Model.getRowDualSol -pyscipopt.recipes.getLocalConss.Model.getRowLPActivity -pyscipopt.recipes.getLocalConss.Model.getRowLinear -pyscipopt.recipes.getLocalConss.Model.getRowNumIntCols -pyscipopt.recipes.getLocalConss.Model.getRowObjParallelism -pyscipopt.recipes.getLocalConss.Model.getRowParallelism -pyscipopt.recipes.getLocalConss.Model.getSiblings -pyscipopt.recipes.getLocalConss.Model.getSlack -pyscipopt.recipes.getLocalConss.Model.getSlackVarIndicator -pyscipopt.recipes.getLocalConss.Model.getSolObjVal -pyscipopt.recipes.getLocalConss.Model.getSolTime -pyscipopt.recipes.getLocalConss.Model.getSolVal -pyscipopt.recipes.getLocalConss.Model.getSols -pyscipopt.recipes.getLocalConss.Model.getSolvingTime -pyscipopt.recipes.getLocalConss.Model.getStage -pyscipopt.recipes.getLocalConss.Model.getStageName -pyscipopt.recipes.getLocalConss.Model.getStatus -pyscipopt.recipes.getLocalConss.Model.getTechVersion -pyscipopt.recipes.getLocalConss.Model.getTermsQuadratic -pyscipopt.recipes.getLocalConss.Model.getTotalTime -pyscipopt.recipes.getLocalConss.Model.getTransformedCons -pyscipopt.recipes.getLocalConss.Model.getTransformedVar -pyscipopt.recipes.getLocalConss.Model.getTreesizeEstimation -pyscipopt.recipes.getLocalConss.Model.getVal -pyscipopt.recipes.getLocalConss.Model.getValsLinear -pyscipopt.recipes.getLocalConss.Model.getVarDict -pyscipopt.recipes.getLocalConss.Model.getVarLbDive -pyscipopt.recipes.getLocalConss.Model.getVarPseudocost -pyscipopt.recipes.getLocalConss.Model.getVarPseudocostScore -pyscipopt.recipes.getLocalConss.Model.getVarRedcost -pyscipopt.recipes.getLocalConss.Model.getVarStrongbranch -pyscipopt.recipes.getLocalConss.Model.getVarStrongbranchLast -pyscipopt.recipes.getLocalConss.Model.getVarStrongbranchNode -pyscipopt.recipes.getLocalConss.Model.getVarUbDive -pyscipopt.recipes.getLocalConss.Model.getVars -pyscipopt.recipes.getLocalConss.Model.getVarsAnd -pyscipopt.recipes.getLocalConss.Model.getWeightsKnapsack -pyscipopt.recipes.getLocalConss.Model.hasPrimalRay -pyscipopt.recipes.getLocalConss.Model.hideOutput -pyscipopt.recipes.getLocalConss.Model.inProbing -pyscipopt.recipes.getLocalConss.Model.inRepropagation -pyscipopt.recipes.getLocalConss.Model.includeBenders -pyscipopt.recipes.getLocalConss.Model.includeBendersDefaultCuts -pyscipopt.recipes.getLocalConss.Model.includeBenderscut -pyscipopt.recipes.getLocalConss.Model.includeBranchrule -pyscipopt.recipes.getLocalConss.Model.includeConshdlr -pyscipopt.recipes.getLocalConss.Model.includeCutsel -pyscipopt.recipes.getLocalConss.Model.includeDefaultPlugins -pyscipopt.recipes.getLocalConss.Model.includeEventhdlr -pyscipopt.recipes.getLocalConss.Model.includeHeur -pyscipopt.recipes.getLocalConss.Model.includeIISfinder -pyscipopt.recipes.getLocalConss.Model.includeNodesel -pyscipopt.recipes.getLocalConss.Model.includePresol -pyscipopt.recipes.getLocalConss.Model.includePricer -pyscipopt.recipes.getLocalConss.Model.includeProp -pyscipopt.recipes.getLocalConss.Model.includeReader -pyscipopt.recipes.getLocalConss.Model.includeRelax -pyscipopt.recipes.getLocalConss.Model.includeSepa -pyscipopt.recipes.getLocalConss.Model.infinity -pyscipopt.recipes.getLocalConss.Model.initBendersDefault -pyscipopt.recipes.getLocalConss.Model.interruptSolve -pyscipopt.recipes.getLocalConss.Model.isAndConsSorted -pyscipopt.recipes.getLocalConss.Model.isCutEfficacious -pyscipopt.recipes.getLocalConss.Model.isEQ -pyscipopt.recipes.getLocalConss.Model.isExact -pyscipopt.recipes.getLocalConss.Model.isFeasEQ -pyscipopt.recipes.getLocalConss.Model.isFeasGE -pyscipopt.recipes.getLocalConss.Model.isFeasGT -pyscipopt.recipes.getLocalConss.Model.isFeasIntegral -pyscipopt.recipes.getLocalConss.Model.isFeasLE -pyscipopt.recipes.getLocalConss.Model.isFeasLT -pyscipopt.recipes.getLocalConss.Model.isFeasNegative -pyscipopt.recipes.getLocalConss.Model.isFeasPositive -pyscipopt.recipes.getLocalConss.Model.isFeasZero -pyscipopt.recipes.getLocalConss.Model.isGE -pyscipopt.recipes.getLocalConss.Model.isGT -pyscipopt.recipes.getLocalConss.Model.isHugeValue -pyscipopt.recipes.getLocalConss.Model.isInfinity -pyscipopt.recipes.getLocalConss.Model.isLE -pyscipopt.recipes.getLocalConss.Model.isLPSolBasic -pyscipopt.recipes.getLocalConss.Model.isLT -pyscipopt.recipes.getLocalConss.Model.isNLPConstructed -pyscipopt.recipes.getLocalConss.Model.isNegative -pyscipopt.recipes.getLocalConss.Model.isObjChangedProbing -pyscipopt.recipes.getLocalConss.Model.isPositive -pyscipopt.recipes.getLocalConss.Model.isZero -pyscipopt.recipes.getLocalConss.Model.lpiGetIterations -pyscipopt.recipes.getLocalConss.Model.markDoNotAggrVar -pyscipopt.recipes.getLocalConss.Model.markDoNotMultaggrVar -pyscipopt.recipes.getLocalConss.Model.newProbingNode -pyscipopt.recipes.getLocalConss.Model.optimize -pyscipopt.recipes.getLocalConss.Model.optimizeNogil -pyscipopt.recipes.getLocalConss.Model.presolve -pyscipopt.recipes.getLocalConss.Model.printBestSol -pyscipopt.recipes.getLocalConss.Model.printCons -pyscipopt.recipes.getLocalConss.Model.printExternalCodeVersions -pyscipopt.recipes.getLocalConss.Model.printNlRow -pyscipopt.recipes.getLocalConss.Model.printProblem -pyscipopt.recipes.getLocalConss.Model.printRow -pyscipopt.recipes.getLocalConss.Model.printSol -pyscipopt.recipes.getLocalConss.Model.printStatistics -pyscipopt.recipes.getLocalConss.Model.printStatisticsJson -pyscipopt.recipes.getLocalConss.Model.printVersion -pyscipopt.recipes.getLocalConss.Model.propagateProbing -pyscipopt.recipes.getLocalConss.Model.readParams -pyscipopt.recipes.getLocalConss.Model.readProblem -pyscipopt.recipes.getLocalConss.Model.readSol -pyscipopt.recipes.getLocalConss.Model.readSolFile -pyscipopt.recipes.getLocalConss.Model.redirectOutput -pyscipopt.recipes.getLocalConss.Model.relax -pyscipopt.recipes.getLocalConss.Model.releaseRow -pyscipopt.recipes.getLocalConss.Model.repropagateNode -pyscipopt.recipes.getLocalConss.Model.resetParam -pyscipopt.recipes.getLocalConss.Model.resetParams -pyscipopt.recipes.getLocalConss.Model.restartSolve -pyscipopt.recipes.getLocalConss.Model.separateSol -pyscipopt.recipes.getLocalConss.Model.setBendersSubproblemIsConvex -pyscipopt.recipes.getLocalConss.Model.setBoolParam -pyscipopt.recipes.getLocalConss.Model.setCharParam -pyscipopt.recipes.getLocalConss.Model.setCheck -pyscipopt.recipes.getLocalConss.Model.setEmphasis -pyscipopt.recipes.getLocalConss.Model.setEnforced -pyscipopt.recipes.getLocalConss.Model.setHeurTiming -pyscipopt.recipes.getLocalConss.Model.setHeuristics -pyscipopt.recipes.getLocalConss.Model.setInitial -pyscipopt.recipes.getLocalConss.Model.setIntParam -pyscipopt.recipes.getLocalConss.Model.setLogfile -pyscipopt.recipes.getLocalConss.Model.setLongintParam -pyscipopt.recipes.getLocalConss.Model.setMaximize -pyscipopt.recipes.getLocalConss.Model.setMinimize -pyscipopt.recipes.getLocalConss.Model.setModifiable -pyscipopt.recipes.getLocalConss.Model.setObjIntegral -pyscipopt.recipes.getLocalConss.Model.setObjective -pyscipopt.recipes.getLocalConss.Model.setObjlimit -pyscipopt.recipes.getLocalConss.Model.setParam -pyscipopt.recipes.getLocalConss.Model.setParams -pyscipopt.recipes.getLocalConss.Model.setParamsCountsols -pyscipopt.recipes.getLocalConss.Model.setPresolve -pyscipopt.recipes.getLocalConss.Model.setProbName -pyscipopt.recipes.getLocalConss.Model.setRealParam -pyscipopt.recipes.getLocalConss.Model.setRelaxSolVal -pyscipopt.recipes.getLocalConss.Model.setRemovable -pyscipopt.recipes.getLocalConss.Model.setSeparating -pyscipopt.recipes.getLocalConss.Model.setSolVal -pyscipopt.recipes.getLocalConss.Model.setStringParam -pyscipopt.recipes.getLocalConss.Model.setupBendersSubproblem -pyscipopt.recipes.getLocalConss.Model.solveBendersSubproblem -pyscipopt.recipes.getLocalConss.Model.solveConcurrent -pyscipopt.recipes.getLocalConss.Model.solveDiveLP -pyscipopt.recipes.getLocalConss.Model.solveProbingLP -pyscipopt.recipes.getLocalConss.Model.sortAndCons -pyscipopt.recipes.getLocalConss.Model.startDive -pyscipopt.recipes.getLocalConss.Model.startProbing -pyscipopt.recipes.getLocalConss.Model.startStrongbranch -pyscipopt.recipes.getLocalConss.Model.tightenVarLb -pyscipopt.recipes.getLocalConss.Model.tightenVarLbGlobal -pyscipopt.recipes.getLocalConss.Model.tightenVarUb -pyscipopt.recipes.getLocalConss.Model.tightenVarUbGlobal -pyscipopt.recipes.getLocalConss.Model.to_ptr -pyscipopt.recipes.getLocalConss.Model.translateSubSol -pyscipopt.recipes.getLocalConss.Model.trySol -pyscipopt.recipes.getLocalConss.Model.updateBendersLowerbounds -pyscipopt.recipes.getLocalConss.Model.updateNodeLowerbound -pyscipopt.recipes.getLocalConss.Model.updateVarPseudocost -pyscipopt.recipes.getLocalConss.Model.version -pyscipopt.recipes.getLocalConss.Model.writeBestSol -pyscipopt.recipes.getLocalConss.Model.writeBestTransSol -pyscipopt.recipes.getLocalConss.Model.writeLP -pyscipopt.recipes.getLocalConss.Model.writeMIP -pyscipopt.recipes.getLocalConss.Model.writeName -pyscipopt.recipes.getLocalConss.Model.writeParams -pyscipopt.recipes.getLocalConss.Model.writeProblem -pyscipopt.recipes.getLocalConss.Model.writeSol -pyscipopt.recipes.getLocalConss.Model.writeStatistics -pyscipopt.recipes.getLocalConss.Model.writeStatisticsJson -pyscipopt.recipes.getLocalConss.Model.writeTransSol -pyscipopt.recipes.infeasibilities.Model -pyscipopt.recipes.infeasibilities.Model._createConsGenNonlinear -pyscipopt.recipes.infeasibilities.Model._createConsLinear -pyscipopt.recipes.infeasibilities.Model._createConsNonlinear -pyscipopt.recipes.infeasibilities.Model._createConsQuadratic -pyscipopt.recipes.infeasibilities.Model._getStageNames -pyscipopt.recipes.infeasibilities.Model.activateBenders -pyscipopt.recipes.infeasibilities.Model.addBendersSubproblem -pyscipopt.recipes.infeasibilities.Model.addCoefKnapsack -pyscipopt.recipes.infeasibilities.Model.addCoefLinear -pyscipopt.recipes.infeasibilities.Model.addCons -pyscipopt.recipes.infeasibilities.Model.addConsAnd -pyscipopt.recipes.infeasibilities.Model.addConsCardinality -pyscipopt.recipes.infeasibilities.Model.addConsCoeff -pyscipopt.recipes.infeasibilities.Model.addConsDisjunction -pyscipopt.recipes.infeasibilities.Model.addConsElemDisjunction -pyscipopt.recipes.infeasibilities.Model.addConsIndicator -pyscipopt.recipes.infeasibilities.Model.addConsKnapsack -pyscipopt.recipes.infeasibilities.Model.addConsLocal -pyscipopt.recipes.infeasibilities.Model.addConsNode -pyscipopt.recipes.infeasibilities.Model.addConsOr -pyscipopt.recipes.infeasibilities.Model.addConsSOS1 -pyscipopt.recipes.infeasibilities.Model.addConsSOS2 -pyscipopt.recipes.infeasibilities.Model.addConsXor -pyscipopt.recipes.infeasibilities.Model.addConss -pyscipopt.recipes.infeasibilities.Model.addCut -pyscipopt.recipes.infeasibilities.Model.addExprNonlinear -pyscipopt.recipes.infeasibilities.Model.addMatrixCons -pyscipopt.recipes.infeasibilities.Model.addMatrixConsIndicator -pyscipopt.recipes.infeasibilities.Model.addMatrixVar -pyscipopt.recipes.infeasibilities.Model.addObjoffset -pyscipopt.recipes.infeasibilities.Model.addPoolCut -pyscipopt.recipes.infeasibilities.Model.addPyCons -pyscipopt.recipes.infeasibilities.Model.addRowDive -pyscipopt.recipes.infeasibilities.Model.addRowExact -pyscipopt.recipes.infeasibilities.Model.addSol -pyscipopt.recipes.infeasibilities.Model.addVar -pyscipopt.recipes.infeasibilities.Model.addVarLocks -pyscipopt.recipes.infeasibilities.Model.addVarLocksType -pyscipopt.recipes.infeasibilities.Model.addVarSOS1 -pyscipopt.recipes.infeasibilities.Model.addVarSOS2 -pyscipopt.recipes.infeasibilities.Model.addVarToRow -pyscipopt.recipes.infeasibilities.Model.allColsInLP -pyscipopt.recipes.infeasibilities.Model.allowNegSlackExact -pyscipopt.recipes.infeasibilities.Model.appendVarSOS1 -pyscipopt.recipes.infeasibilities.Model.appendVarSOS2 -pyscipopt.recipes.infeasibilities.Model.applyCutsProbing -pyscipopt.recipes.infeasibilities.Model.attachEventHandlerCallback -pyscipopt.recipes.infeasibilities.Model.backtrackProbing -pyscipopt.recipes.infeasibilities.Model.branchLPExact -pyscipopt.recipes.infeasibilities.Model.branchVar -pyscipopt.recipes.infeasibilities.Model.branchVarVal -pyscipopt.recipes.infeasibilities.Model.cacheRowExtensions -pyscipopt.recipes.infeasibilities.Model.calcChildEstimate -pyscipopt.recipes.infeasibilities.Model.calcNodeselPriority -pyscipopt.recipes.infeasibilities.Model.catchEvent -pyscipopt.recipes.infeasibilities.Model.catchRowEvent -pyscipopt.recipes.infeasibilities.Model.catchVarEvent -pyscipopt.recipes.infeasibilities.Model.checkBendersSubproblemOptimality -pyscipopt.recipes.infeasibilities.Model.checkQuadraticNonlinear -pyscipopt.recipes.infeasibilities.Model.checkSol -pyscipopt.recipes.infeasibilities.Model.chgCapacityKnapsack -pyscipopt.recipes.infeasibilities.Model.chgCoefLinear -pyscipopt.recipes.infeasibilities.Model.chgLhs -pyscipopt.recipes.infeasibilities.Model.chgReoptObjective -pyscipopt.recipes.infeasibilities.Model.chgRhs -pyscipopt.recipes.infeasibilities.Model.chgRowLhsDive -pyscipopt.recipes.infeasibilities.Model.chgRowRhsDive -pyscipopt.recipes.infeasibilities.Model.chgVarBranchPriority -pyscipopt.recipes.infeasibilities.Model.chgVarLb -pyscipopt.recipes.infeasibilities.Model.chgVarLbDive -pyscipopt.recipes.infeasibilities.Model.chgVarLbGlobal -pyscipopt.recipes.infeasibilities.Model.chgVarLbNode -pyscipopt.recipes.infeasibilities.Model.chgVarLbProbing -pyscipopt.recipes.infeasibilities.Model.chgVarObjDive -pyscipopt.recipes.infeasibilities.Model.chgVarObjProbing -pyscipopt.recipes.infeasibilities.Model.chgVarType -pyscipopt.recipes.infeasibilities.Model.chgVarUb -pyscipopt.recipes.infeasibilities.Model.chgVarUbDive -pyscipopt.recipes.infeasibilities.Model.chgVarUbGlobal -pyscipopt.recipes.infeasibilities.Model.chgVarUbNode -pyscipopt.recipes.infeasibilities.Model.chgVarUbProbing -pyscipopt.recipes.infeasibilities.Model.computeBestSolSubproblems -pyscipopt.recipes.infeasibilities.Model.constructLP -pyscipopt.recipes.infeasibilities.Model.copyLargeNeighborhoodSearch -pyscipopt.recipes.infeasibilities.Model.count -pyscipopt.recipes.infeasibilities.Model.createChild -pyscipopt.recipes.infeasibilities.Model.createCons -pyscipopt.recipes.infeasibilities.Model.createConsFromExpr -pyscipopt.recipes.infeasibilities.Model.createEmptyRowSepa -pyscipopt.recipes.infeasibilities.Model.createEmptyRowUnspec -pyscipopt.recipes.infeasibilities.Model.createOrigSol -pyscipopt.recipes.infeasibilities.Model.createPartialSol -pyscipopt.recipes.infeasibilities.Model.createProbBasic -pyscipopt.recipes.infeasibilities.Model.createSol -pyscipopt.recipes.infeasibilities.Model.cutoffNode -pyscipopt.recipes.infeasibilities.Model.deactivatePricer -pyscipopt.recipes.infeasibilities.Model.delCoefLinear -pyscipopt.recipes.infeasibilities.Model.delCons -pyscipopt.recipes.infeasibilities.Model.delConsLocal -pyscipopt.recipes.infeasibilities.Model.delVar -pyscipopt.recipes.infeasibilities.Model.disableDebugSol -pyscipopt.recipes.infeasibilities.Model.disablePropagation -pyscipopt.recipes.infeasibilities.Model.dropEvent -pyscipopt.recipes.infeasibilities.Model.dropRowEvent -pyscipopt.recipes.infeasibilities.Model.dropVarEvent -pyscipopt.recipes.infeasibilities.Model.enableDebugSol -pyscipopt.recipes.infeasibilities.Model.enableExactSolving -pyscipopt.recipes.infeasibilities.Model.enableReoptimization -pyscipopt.recipes.infeasibilities.Model.endDive -pyscipopt.recipes.infeasibilities.Model.endProbing -pyscipopt.recipes.infeasibilities.Model.endStrongbranch -pyscipopt.recipes.infeasibilities.Model.epsilon -pyscipopt.recipes.infeasibilities.Model.feasCeil -pyscipopt.recipes.infeasibilities.Model.feasFloor -pyscipopt.recipes.infeasibilities.Model.feasFrac -pyscipopt.recipes.infeasibilities.Model.feasRound -pyscipopt.recipes.infeasibilities.Model.feastol -pyscipopt.recipes.infeasibilities.Model.fixVar -pyscipopt.recipes.infeasibilities.Model.fixVarProbing -pyscipopt.recipes.infeasibilities.Model.flushRowExtensions -pyscipopt.recipes.infeasibilities.Model.frac -pyscipopt.recipes.infeasibilities.Model.freeBendersSubproblems -pyscipopt.recipes.infeasibilities.Model.freeProb -pyscipopt.recipes.infeasibilities.Model.freeReoptSolve -pyscipopt.recipes.infeasibilities.Model.freeSol -pyscipopt.recipes.infeasibilities.Model.freeTransform -pyscipopt.recipes.infeasibilities.Model.from_ptr -pyscipopt.recipes.infeasibilities.Model.generateIIS -pyscipopt.recipes.infeasibilities.Model.getActivity -pyscipopt.recipes.infeasibilities.Model.getBendersAuxiliaryVar -pyscipopt.recipes.infeasibilities.Model.getBendersSubproblem -pyscipopt.recipes.infeasibilities.Model.getBendersVar -pyscipopt.recipes.infeasibilities.Model.getBestChild -pyscipopt.recipes.infeasibilities.Model.getBestLeaf -pyscipopt.recipes.infeasibilities.Model.getBestNode -pyscipopt.recipes.infeasibilities.Model.getBestSibling -pyscipopt.recipes.infeasibilities.Model.getBestSol -pyscipopt.recipes.infeasibilities.Model.getBestboundNode -pyscipopt.recipes.infeasibilities.Model.getBipartiteGraphRepresentation -pyscipopt.recipes.infeasibilities.Model.getBranchScoreMultiple -pyscipopt.recipes.infeasibilities.Model.getCapacityKnapsack -pyscipopt.recipes.infeasibilities.Model.getChildren -pyscipopt.recipes.infeasibilities.Model.getColRedCost -pyscipopt.recipes.infeasibilities.Model.getCondition -pyscipopt.recipes.infeasibilities.Model.getConsNVars -pyscipopt.recipes.infeasibilities.Model.getConsVals -pyscipopt.recipes.infeasibilities.Model.getConsVars -pyscipopt.recipes.infeasibilities.Model.getConss -pyscipopt.recipes.infeasibilities.Model.getCurrentNode -pyscipopt.recipes.infeasibilities.Model.getCutEfficacy -pyscipopt.recipes.infeasibilities.Model.getCutLPSolCutoffDistance -pyscipopt.recipes.infeasibilities.Model.getCutoffbound -pyscipopt.recipes.infeasibilities.Model.getDepth -pyscipopt.recipes.infeasibilities.Model.getDualMultiplier -pyscipopt.recipes.infeasibilities.Model.getDualSolVal -pyscipopt.recipes.infeasibilities.Model.getDualbound -pyscipopt.recipes.infeasibilities.Model.getDualboundRoot -pyscipopt.recipes.infeasibilities.Model.getDualfarkasKnapsack -pyscipopt.recipes.infeasibilities.Model.getDualfarkasLinear -pyscipopt.recipes.infeasibilities.Model.getDualsolKnapsack -pyscipopt.recipes.infeasibilities.Model.getDualsolLinear -pyscipopt.recipes.infeasibilities.Model.getGap -pyscipopt.recipes.infeasibilities.Model.getHeurTiming -pyscipopt.recipes.infeasibilities.Model.getIIS -pyscipopt.recipes.infeasibilities.Model.getLPBInvARow -pyscipopt.recipes.infeasibilities.Model.getLPBInvRow -pyscipopt.recipes.infeasibilities.Model.getLPBasisInd -pyscipopt.recipes.infeasibilities.Model.getLPBranchCands -pyscipopt.recipes.infeasibilities.Model.getLPColsData -pyscipopt.recipes.infeasibilities.Model.getLPObjVal -pyscipopt.recipes.infeasibilities.Model.getLPRowsData -pyscipopt.recipes.infeasibilities.Model.getLPSolstat -pyscipopt.recipes.infeasibilities.Model.getLeaves -pyscipopt.recipes.infeasibilities.Model.getLhs -pyscipopt.recipes.infeasibilities.Model.getLinearConsIndicator -pyscipopt.recipes.infeasibilities.Model.getLocalEstimate -pyscipopt.recipes.infeasibilities.Model.getLowerbound -pyscipopt.recipes.infeasibilities.Model.getMajorVersion -pyscipopt.recipes.infeasibilities.Model.getMaxDepth -pyscipopt.recipes.infeasibilities.Model.getMinorVersion -pyscipopt.recipes.infeasibilities.Model.getNBestSolsFound -pyscipopt.recipes.infeasibilities.Model.getNBinVars -pyscipopt.recipes.infeasibilities.Model.getNChildren -pyscipopt.recipes.infeasibilities.Model.getNConss -pyscipopt.recipes.infeasibilities.Model.getNContVars -pyscipopt.recipes.infeasibilities.Model.getNCountedSols -pyscipopt.recipes.infeasibilities.Model.getNCuts -pyscipopt.recipes.infeasibilities.Model.getNCutsApplied -pyscipopt.recipes.infeasibilities.Model.getNFeasibleLeaves -pyscipopt.recipes.infeasibilities.Model.getNImplVars -pyscipopt.recipes.infeasibilities.Model.getNInfeasibleLeaves -pyscipopt.recipes.infeasibilities.Model.getNIntVars -pyscipopt.recipes.infeasibilities.Model.getNLPBranchCands -pyscipopt.recipes.infeasibilities.Model.getNLPCols -pyscipopt.recipes.infeasibilities.Model.getNLPIterations -pyscipopt.recipes.infeasibilities.Model.getNLPRows -pyscipopt.recipes.infeasibilities.Model.getNLPs -pyscipopt.recipes.infeasibilities.Model.getNLeaves -pyscipopt.recipes.infeasibilities.Model.getNLimSolsFound -pyscipopt.recipes.infeasibilities.Model.getNNlRows -pyscipopt.recipes.infeasibilities.Model.getNNodeLPIterations -pyscipopt.recipes.infeasibilities.Model.getNNodes -pyscipopt.recipes.infeasibilities.Model.getNReaders -pyscipopt.recipes.infeasibilities.Model.getNSepaRounds -pyscipopt.recipes.infeasibilities.Model.getNSiblings -pyscipopt.recipes.infeasibilities.Model.getNSols -pyscipopt.recipes.infeasibilities.Model.getNSolsFound -pyscipopt.recipes.infeasibilities.Model.getNStrongbranchLPIterations -pyscipopt.recipes.infeasibilities.Model.getNTotalNodes -pyscipopt.recipes.infeasibilities.Model.getNVars -pyscipopt.recipes.infeasibilities.Model.getNVarsAnd -pyscipopt.recipes.infeasibilities.Model.getNlRowActivityBounds -pyscipopt.recipes.infeasibilities.Model.getNlRowSolActivity -pyscipopt.recipes.infeasibilities.Model.getNlRowSolFeasibility -pyscipopt.recipes.infeasibilities.Model.getNlRows -pyscipopt.recipes.infeasibilities.Model.getObjVal -pyscipopt.recipes.infeasibilities.Model.getObjective -pyscipopt.recipes.infeasibilities.Model.getObjectiveSense -pyscipopt.recipes.infeasibilities.Model.getObjlimit -pyscipopt.recipes.infeasibilities.Model.getObjoffset -pyscipopt.recipes.infeasibilities.Model.getOpenNodes -pyscipopt.recipes.infeasibilities.Model.getParam -pyscipopt.recipes.infeasibilities.Model.getParams -pyscipopt.recipes.infeasibilities.Model.getPlungeDepth -pyscipopt.recipes.infeasibilities.Model.getPresolvingTime -pyscipopt.recipes.infeasibilities.Model.getPrimalRay -pyscipopt.recipes.infeasibilities.Model.getPrimalRayVal -pyscipopt.recipes.infeasibilities.Model.getPrimalbound -pyscipopt.recipes.infeasibilities.Model.getPrioChild -pyscipopt.recipes.infeasibilities.Model.getPrioSibling -pyscipopt.recipes.infeasibilities.Model.getProbName -pyscipopt.recipes.infeasibilities.Model.getProbingDepth -pyscipopt.recipes.infeasibilities.Model.getPseudoBranchCands -pyscipopt.recipes.infeasibilities.Model.getReadingTime -pyscipopt.recipes.infeasibilities.Model.getResultantAnd -pyscipopt.recipes.infeasibilities.Model.getRhs -pyscipopt.recipes.infeasibilities.Model.getRowActivity -pyscipopt.recipes.infeasibilities.Model.getRowDualSol -pyscipopt.recipes.infeasibilities.Model.getRowLPActivity -pyscipopt.recipes.infeasibilities.Model.getRowLinear -pyscipopt.recipes.infeasibilities.Model.getRowNumIntCols -pyscipopt.recipes.infeasibilities.Model.getRowObjParallelism -pyscipopt.recipes.infeasibilities.Model.getRowParallelism -pyscipopt.recipes.infeasibilities.Model.getSiblings -pyscipopt.recipes.infeasibilities.Model.getSlack -pyscipopt.recipes.infeasibilities.Model.getSlackVarIndicator -pyscipopt.recipes.infeasibilities.Model.getSolObjVal -pyscipopt.recipes.infeasibilities.Model.getSolTime -pyscipopt.recipes.infeasibilities.Model.getSolVal -pyscipopt.recipes.infeasibilities.Model.getSols -pyscipopt.recipes.infeasibilities.Model.getSolvingTime -pyscipopt.recipes.infeasibilities.Model.getStage -pyscipopt.recipes.infeasibilities.Model.getStageName -pyscipopt.recipes.infeasibilities.Model.getStatus -pyscipopt.recipes.infeasibilities.Model.getTechVersion -pyscipopt.recipes.infeasibilities.Model.getTermsQuadratic -pyscipopt.recipes.infeasibilities.Model.getTotalTime -pyscipopt.recipes.infeasibilities.Model.getTransformedCons -pyscipopt.recipes.infeasibilities.Model.getTransformedVar -pyscipopt.recipes.infeasibilities.Model.getTreesizeEstimation -pyscipopt.recipes.infeasibilities.Model.getVal -pyscipopt.recipes.infeasibilities.Model.getValsLinear -pyscipopt.recipes.infeasibilities.Model.getVarDict -pyscipopt.recipes.infeasibilities.Model.getVarLbDive -pyscipopt.recipes.infeasibilities.Model.getVarPseudocost -pyscipopt.recipes.infeasibilities.Model.getVarPseudocostScore -pyscipopt.recipes.infeasibilities.Model.getVarRedcost -pyscipopt.recipes.infeasibilities.Model.getVarStrongbranch -pyscipopt.recipes.infeasibilities.Model.getVarStrongbranchLast -pyscipopt.recipes.infeasibilities.Model.getVarStrongbranchNode -pyscipopt.recipes.infeasibilities.Model.getVarUbDive -pyscipopt.recipes.infeasibilities.Model.getVars -pyscipopt.recipes.infeasibilities.Model.getVarsAnd -pyscipopt.recipes.infeasibilities.Model.getWeightsKnapsack -pyscipopt.recipes.infeasibilities.Model.hasPrimalRay -pyscipopt.recipes.infeasibilities.Model.hideOutput -pyscipopt.recipes.infeasibilities.Model.inProbing -pyscipopt.recipes.infeasibilities.Model.inRepropagation -pyscipopt.recipes.infeasibilities.Model.includeBenders -pyscipopt.recipes.infeasibilities.Model.includeBendersDefaultCuts -pyscipopt.recipes.infeasibilities.Model.includeBenderscut -pyscipopt.recipes.infeasibilities.Model.includeBranchrule -pyscipopt.recipes.infeasibilities.Model.includeConshdlr -pyscipopt.recipes.infeasibilities.Model.includeCutsel -pyscipopt.recipes.infeasibilities.Model.includeDefaultPlugins -pyscipopt.recipes.infeasibilities.Model.includeEventhdlr -pyscipopt.recipes.infeasibilities.Model.includeHeur -pyscipopt.recipes.infeasibilities.Model.includeIISfinder -pyscipopt.recipes.infeasibilities.Model.includeNodesel -pyscipopt.recipes.infeasibilities.Model.includePresol -pyscipopt.recipes.infeasibilities.Model.includePricer -pyscipopt.recipes.infeasibilities.Model.includeProp -pyscipopt.recipes.infeasibilities.Model.includeReader -pyscipopt.recipes.infeasibilities.Model.includeRelax -pyscipopt.recipes.infeasibilities.Model.includeSepa -pyscipopt.recipes.infeasibilities.Model.infinity -pyscipopt.recipes.infeasibilities.Model.initBendersDefault -pyscipopt.recipes.infeasibilities.Model.interruptSolve -pyscipopt.recipes.infeasibilities.Model.isAndConsSorted -pyscipopt.recipes.infeasibilities.Model.isCutEfficacious -pyscipopt.recipes.infeasibilities.Model.isEQ -pyscipopt.recipes.infeasibilities.Model.isExact -pyscipopt.recipes.infeasibilities.Model.isFeasEQ -pyscipopt.recipes.infeasibilities.Model.isFeasGE -pyscipopt.recipes.infeasibilities.Model.isFeasGT -pyscipopt.recipes.infeasibilities.Model.isFeasIntegral -pyscipopt.recipes.infeasibilities.Model.isFeasLE -pyscipopt.recipes.infeasibilities.Model.isFeasLT -pyscipopt.recipes.infeasibilities.Model.isFeasNegative -pyscipopt.recipes.infeasibilities.Model.isFeasPositive -pyscipopt.recipes.infeasibilities.Model.isFeasZero -pyscipopt.recipes.infeasibilities.Model.isGE -pyscipopt.recipes.infeasibilities.Model.isGT -pyscipopt.recipes.infeasibilities.Model.isHugeValue -pyscipopt.recipes.infeasibilities.Model.isInfinity -pyscipopt.recipes.infeasibilities.Model.isLE -pyscipopt.recipes.infeasibilities.Model.isLPSolBasic -pyscipopt.recipes.infeasibilities.Model.isLT -pyscipopt.recipes.infeasibilities.Model.isNLPConstructed -pyscipopt.recipes.infeasibilities.Model.isNegative -pyscipopt.recipes.infeasibilities.Model.isObjChangedProbing -pyscipopt.recipes.infeasibilities.Model.isPositive -pyscipopt.recipes.infeasibilities.Model.isZero -pyscipopt.recipes.infeasibilities.Model.lpiGetIterations -pyscipopt.recipes.infeasibilities.Model.markDoNotAggrVar -pyscipopt.recipes.infeasibilities.Model.markDoNotMultaggrVar -pyscipopt.recipes.infeasibilities.Model.newProbingNode -pyscipopt.recipes.infeasibilities.Model.optimize -pyscipopt.recipes.infeasibilities.Model.optimizeNogil -pyscipopt.recipes.infeasibilities.Model.presolve -pyscipopt.recipes.infeasibilities.Model.printBestSol -pyscipopt.recipes.infeasibilities.Model.printCons -pyscipopt.recipes.infeasibilities.Model.printExternalCodeVersions -pyscipopt.recipes.infeasibilities.Model.printNlRow -pyscipopt.recipes.infeasibilities.Model.printProblem -pyscipopt.recipes.infeasibilities.Model.printRow -pyscipopt.recipes.infeasibilities.Model.printSol -pyscipopt.recipes.infeasibilities.Model.printStatistics -pyscipopt.recipes.infeasibilities.Model.printStatisticsJson -pyscipopt.recipes.infeasibilities.Model.printVersion -pyscipopt.recipes.infeasibilities.Model.propagateProbing -pyscipopt.recipes.infeasibilities.Model.readParams -pyscipopt.recipes.infeasibilities.Model.readProblem -pyscipopt.recipes.infeasibilities.Model.readSol -pyscipopt.recipes.infeasibilities.Model.readSolFile -pyscipopt.recipes.infeasibilities.Model.redirectOutput -pyscipopt.recipes.infeasibilities.Model.relax -pyscipopt.recipes.infeasibilities.Model.releaseRow -pyscipopt.recipes.infeasibilities.Model.repropagateNode -pyscipopt.recipes.infeasibilities.Model.resetParam -pyscipopt.recipes.infeasibilities.Model.resetParams -pyscipopt.recipes.infeasibilities.Model.restartSolve -pyscipopt.recipes.infeasibilities.Model.separateSol -pyscipopt.recipes.infeasibilities.Model.setBendersSubproblemIsConvex -pyscipopt.recipes.infeasibilities.Model.setBoolParam -pyscipopt.recipes.infeasibilities.Model.setCharParam -pyscipopt.recipes.infeasibilities.Model.setCheck -pyscipopt.recipes.infeasibilities.Model.setEmphasis -pyscipopt.recipes.infeasibilities.Model.setEnforced -pyscipopt.recipes.infeasibilities.Model.setHeurTiming -pyscipopt.recipes.infeasibilities.Model.setHeuristics -pyscipopt.recipes.infeasibilities.Model.setInitial -pyscipopt.recipes.infeasibilities.Model.setIntParam -pyscipopt.recipes.infeasibilities.Model.setLogfile -pyscipopt.recipes.infeasibilities.Model.setLongintParam -pyscipopt.recipes.infeasibilities.Model.setMaximize -pyscipopt.recipes.infeasibilities.Model.setMinimize -pyscipopt.recipes.infeasibilities.Model.setModifiable -pyscipopt.recipes.infeasibilities.Model.setObjIntegral -pyscipopt.recipes.infeasibilities.Model.setObjective -pyscipopt.recipes.infeasibilities.Model.setObjlimit -pyscipopt.recipes.infeasibilities.Model.setParam -pyscipopt.recipes.infeasibilities.Model.setParams -pyscipopt.recipes.infeasibilities.Model.setParamsCountsols -pyscipopt.recipes.infeasibilities.Model.setPresolve -pyscipopt.recipes.infeasibilities.Model.setProbName -pyscipopt.recipes.infeasibilities.Model.setRealParam -pyscipopt.recipes.infeasibilities.Model.setRelaxSolVal -pyscipopt.recipes.infeasibilities.Model.setRemovable -pyscipopt.recipes.infeasibilities.Model.setSeparating -pyscipopt.recipes.infeasibilities.Model.setSolVal -pyscipopt.recipes.infeasibilities.Model.setStringParam -pyscipopt.recipes.infeasibilities.Model.setupBendersSubproblem -pyscipopt.recipes.infeasibilities.Model.solveBendersSubproblem -pyscipopt.recipes.infeasibilities.Model.solveConcurrent -pyscipopt.recipes.infeasibilities.Model.solveDiveLP -pyscipopt.recipes.infeasibilities.Model.solveProbingLP -pyscipopt.recipes.infeasibilities.Model.sortAndCons -pyscipopt.recipes.infeasibilities.Model.startDive -pyscipopt.recipes.infeasibilities.Model.startProbing -pyscipopt.recipes.infeasibilities.Model.startStrongbranch -pyscipopt.recipes.infeasibilities.Model.tightenVarLb -pyscipopt.recipes.infeasibilities.Model.tightenVarLbGlobal -pyscipopt.recipes.infeasibilities.Model.tightenVarUb -pyscipopt.recipes.infeasibilities.Model.tightenVarUbGlobal -pyscipopt.recipes.infeasibilities.Model.to_ptr -pyscipopt.recipes.infeasibilities.Model.translateSubSol -pyscipopt.recipes.infeasibilities.Model.trySol -pyscipopt.recipes.infeasibilities.Model.updateBendersLowerbounds -pyscipopt.recipes.infeasibilities.Model.updateNodeLowerbound -pyscipopt.recipes.infeasibilities.Model.updateVarPseudocost -pyscipopt.recipes.infeasibilities.Model.version -pyscipopt.recipes.infeasibilities.Model.writeBestSol -pyscipopt.recipes.infeasibilities.Model.writeBestTransSol -pyscipopt.recipes.infeasibilities.Model.writeLP -pyscipopt.recipes.infeasibilities.Model.writeMIP -pyscipopt.recipes.infeasibilities.Model.writeName -pyscipopt.recipes.infeasibilities.Model.writeParams -pyscipopt.recipes.infeasibilities.Model.writeProblem -pyscipopt.recipes.infeasibilities.Model.writeSol -pyscipopt.recipes.infeasibilities.Model.writeStatistics -pyscipopt.recipes.infeasibilities.Model.writeStatisticsJson -pyscipopt.recipes.infeasibilities.Model.writeTransSol -pyscipopt.recipes.nonlinear.Model -pyscipopt.recipes.nonlinear.Model._createConsGenNonlinear -pyscipopt.recipes.nonlinear.Model._createConsLinear -pyscipopt.recipes.nonlinear.Model._createConsNonlinear -pyscipopt.recipes.nonlinear.Model._createConsQuadratic -pyscipopt.recipes.nonlinear.Model._getStageNames -pyscipopt.recipes.nonlinear.Model.activateBenders -pyscipopt.recipes.nonlinear.Model.addBendersSubproblem -pyscipopt.recipes.nonlinear.Model.addCoefKnapsack -pyscipopt.recipes.nonlinear.Model.addCoefLinear -pyscipopt.recipes.nonlinear.Model.addCons -pyscipopt.recipes.nonlinear.Model.addConsAnd -pyscipopt.recipes.nonlinear.Model.addConsCardinality -pyscipopt.recipes.nonlinear.Model.addConsCoeff -pyscipopt.recipes.nonlinear.Model.addConsDisjunction -pyscipopt.recipes.nonlinear.Model.addConsElemDisjunction -pyscipopt.recipes.nonlinear.Model.addConsIndicator -pyscipopt.recipes.nonlinear.Model.addConsKnapsack -pyscipopt.recipes.nonlinear.Model.addConsLocal -pyscipopt.recipes.nonlinear.Model.addConsNode -pyscipopt.recipes.nonlinear.Model.addConsOr -pyscipopt.recipes.nonlinear.Model.addConsSOS1 -pyscipopt.recipes.nonlinear.Model.addConsSOS2 -pyscipopt.recipes.nonlinear.Model.addConsXor -pyscipopt.recipes.nonlinear.Model.addConss -pyscipopt.recipes.nonlinear.Model.addCut -pyscipopt.recipes.nonlinear.Model.addExprNonlinear -pyscipopt.recipes.nonlinear.Model.addMatrixCons -pyscipopt.recipes.nonlinear.Model.addMatrixConsIndicator -pyscipopt.recipes.nonlinear.Model.addMatrixVar -pyscipopt.recipes.nonlinear.Model.addObjoffset -pyscipopt.recipes.nonlinear.Model.addPoolCut -pyscipopt.recipes.nonlinear.Model.addPyCons -pyscipopt.recipes.nonlinear.Model.addRowDive -pyscipopt.recipes.nonlinear.Model.addRowExact -pyscipopt.recipes.nonlinear.Model.addSol -pyscipopt.recipes.nonlinear.Model.addVar -pyscipopt.recipes.nonlinear.Model.addVarLocks -pyscipopt.recipes.nonlinear.Model.addVarLocksType -pyscipopt.recipes.nonlinear.Model.addVarSOS1 -pyscipopt.recipes.nonlinear.Model.addVarSOS2 -pyscipopt.recipes.nonlinear.Model.addVarToRow -pyscipopt.recipes.nonlinear.Model.allColsInLP -pyscipopt.recipes.nonlinear.Model.allowNegSlackExact -pyscipopt.recipes.nonlinear.Model.appendVarSOS1 -pyscipopt.recipes.nonlinear.Model.appendVarSOS2 -pyscipopt.recipes.nonlinear.Model.applyCutsProbing -pyscipopt.recipes.nonlinear.Model.attachEventHandlerCallback -pyscipopt.recipes.nonlinear.Model.backtrackProbing -pyscipopt.recipes.nonlinear.Model.branchLPExact -pyscipopt.recipes.nonlinear.Model.branchVar -pyscipopt.recipes.nonlinear.Model.branchVarVal -pyscipopt.recipes.nonlinear.Model.cacheRowExtensions -pyscipopt.recipes.nonlinear.Model.calcChildEstimate -pyscipopt.recipes.nonlinear.Model.calcNodeselPriority -pyscipopt.recipes.nonlinear.Model.catchEvent -pyscipopt.recipes.nonlinear.Model.catchRowEvent -pyscipopt.recipes.nonlinear.Model.catchVarEvent -pyscipopt.recipes.nonlinear.Model.checkBendersSubproblemOptimality -pyscipopt.recipes.nonlinear.Model.checkQuadraticNonlinear -pyscipopt.recipes.nonlinear.Model.checkSol -pyscipopt.recipes.nonlinear.Model.chgCapacityKnapsack -pyscipopt.recipes.nonlinear.Model.chgCoefLinear -pyscipopt.recipes.nonlinear.Model.chgLhs -pyscipopt.recipes.nonlinear.Model.chgReoptObjective -pyscipopt.recipes.nonlinear.Model.chgRhs -pyscipopt.recipes.nonlinear.Model.chgRowLhsDive -pyscipopt.recipes.nonlinear.Model.chgRowRhsDive -pyscipopt.recipes.nonlinear.Model.chgVarBranchPriority -pyscipopt.recipes.nonlinear.Model.chgVarLb -pyscipopt.recipes.nonlinear.Model.chgVarLbDive -pyscipopt.recipes.nonlinear.Model.chgVarLbGlobal -pyscipopt.recipes.nonlinear.Model.chgVarLbNode -pyscipopt.recipes.nonlinear.Model.chgVarLbProbing -pyscipopt.recipes.nonlinear.Model.chgVarObjDive -pyscipopt.recipes.nonlinear.Model.chgVarObjProbing -pyscipopt.recipes.nonlinear.Model.chgVarType -pyscipopt.recipes.nonlinear.Model.chgVarUb -pyscipopt.recipes.nonlinear.Model.chgVarUbDive -pyscipopt.recipes.nonlinear.Model.chgVarUbGlobal -pyscipopt.recipes.nonlinear.Model.chgVarUbNode -pyscipopt.recipes.nonlinear.Model.chgVarUbProbing -pyscipopt.recipes.nonlinear.Model.computeBestSolSubproblems -pyscipopt.recipes.nonlinear.Model.constructLP -pyscipopt.recipes.nonlinear.Model.copyLargeNeighborhoodSearch -pyscipopt.recipes.nonlinear.Model.count -pyscipopt.recipes.nonlinear.Model.createChild -pyscipopt.recipes.nonlinear.Model.createCons -pyscipopt.recipes.nonlinear.Model.createConsFromExpr -pyscipopt.recipes.nonlinear.Model.createEmptyRowSepa -pyscipopt.recipes.nonlinear.Model.createEmptyRowUnspec -pyscipopt.recipes.nonlinear.Model.createOrigSol -pyscipopt.recipes.nonlinear.Model.createPartialSol -pyscipopt.recipes.nonlinear.Model.createProbBasic -pyscipopt.recipes.nonlinear.Model.createSol -pyscipopt.recipes.nonlinear.Model.cutoffNode -pyscipopt.recipes.nonlinear.Model.deactivatePricer -pyscipopt.recipes.nonlinear.Model.delCoefLinear -pyscipopt.recipes.nonlinear.Model.delCons -pyscipopt.recipes.nonlinear.Model.delConsLocal -pyscipopt.recipes.nonlinear.Model.delVar -pyscipopt.recipes.nonlinear.Model.disableDebugSol -pyscipopt.recipes.nonlinear.Model.disablePropagation -pyscipopt.recipes.nonlinear.Model.dropEvent -pyscipopt.recipes.nonlinear.Model.dropRowEvent -pyscipopt.recipes.nonlinear.Model.dropVarEvent -pyscipopt.recipes.nonlinear.Model.enableDebugSol -pyscipopt.recipes.nonlinear.Model.enableExactSolving -pyscipopt.recipes.nonlinear.Model.enableReoptimization -pyscipopt.recipes.nonlinear.Model.endDive -pyscipopt.recipes.nonlinear.Model.endProbing -pyscipopt.recipes.nonlinear.Model.endStrongbranch -pyscipopt.recipes.nonlinear.Model.epsilon -pyscipopt.recipes.nonlinear.Model.feasCeil -pyscipopt.recipes.nonlinear.Model.feasFloor -pyscipopt.recipes.nonlinear.Model.feasFrac -pyscipopt.recipes.nonlinear.Model.feasRound -pyscipopt.recipes.nonlinear.Model.feastol -pyscipopt.recipes.nonlinear.Model.fixVar -pyscipopt.recipes.nonlinear.Model.fixVarProbing -pyscipopt.recipes.nonlinear.Model.flushRowExtensions -pyscipopt.recipes.nonlinear.Model.frac -pyscipopt.recipes.nonlinear.Model.freeBendersSubproblems -pyscipopt.recipes.nonlinear.Model.freeProb -pyscipopt.recipes.nonlinear.Model.freeReoptSolve -pyscipopt.recipes.nonlinear.Model.freeSol -pyscipopt.recipes.nonlinear.Model.freeTransform -pyscipopt.recipes.nonlinear.Model.from_ptr -pyscipopt.recipes.nonlinear.Model.generateIIS -pyscipopt.recipes.nonlinear.Model.getActivity -pyscipopt.recipes.nonlinear.Model.getBendersAuxiliaryVar -pyscipopt.recipes.nonlinear.Model.getBendersSubproblem -pyscipopt.recipes.nonlinear.Model.getBendersVar -pyscipopt.recipes.nonlinear.Model.getBestChild -pyscipopt.recipes.nonlinear.Model.getBestLeaf -pyscipopt.recipes.nonlinear.Model.getBestNode -pyscipopt.recipes.nonlinear.Model.getBestSibling -pyscipopt.recipes.nonlinear.Model.getBestSol -pyscipopt.recipes.nonlinear.Model.getBestboundNode -pyscipopt.recipes.nonlinear.Model.getBipartiteGraphRepresentation -pyscipopt.recipes.nonlinear.Model.getBranchScoreMultiple -pyscipopt.recipes.nonlinear.Model.getCapacityKnapsack -pyscipopt.recipes.nonlinear.Model.getChildren -pyscipopt.recipes.nonlinear.Model.getColRedCost -pyscipopt.recipes.nonlinear.Model.getCondition -pyscipopt.recipes.nonlinear.Model.getConsNVars -pyscipopt.recipes.nonlinear.Model.getConsVals -pyscipopt.recipes.nonlinear.Model.getConsVars -pyscipopt.recipes.nonlinear.Model.getConss -pyscipopt.recipes.nonlinear.Model.getCurrentNode -pyscipopt.recipes.nonlinear.Model.getCutEfficacy -pyscipopt.recipes.nonlinear.Model.getCutLPSolCutoffDistance -pyscipopt.recipes.nonlinear.Model.getCutoffbound -pyscipopt.recipes.nonlinear.Model.getDepth -pyscipopt.recipes.nonlinear.Model.getDualMultiplier -pyscipopt.recipes.nonlinear.Model.getDualSolVal -pyscipopt.recipes.nonlinear.Model.getDualbound -pyscipopt.recipes.nonlinear.Model.getDualboundRoot -pyscipopt.recipes.nonlinear.Model.getDualfarkasKnapsack -pyscipopt.recipes.nonlinear.Model.getDualfarkasLinear -pyscipopt.recipes.nonlinear.Model.getDualsolKnapsack -pyscipopt.recipes.nonlinear.Model.getDualsolLinear -pyscipopt.recipes.nonlinear.Model.getGap -pyscipopt.recipes.nonlinear.Model.getHeurTiming -pyscipopt.recipes.nonlinear.Model.getIIS -pyscipopt.recipes.nonlinear.Model.getLPBInvARow -pyscipopt.recipes.nonlinear.Model.getLPBInvRow -pyscipopt.recipes.nonlinear.Model.getLPBasisInd -pyscipopt.recipes.nonlinear.Model.getLPBranchCands -pyscipopt.recipes.nonlinear.Model.getLPColsData -pyscipopt.recipes.nonlinear.Model.getLPObjVal -pyscipopt.recipes.nonlinear.Model.getLPRowsData -pyscipopt.recipes.nonlinear.Model.getLPSolstat -pyscipopt.recipes.nonlinear.Model.getLeaves -pyscipopt.recipes.nonlinear.Model.getLhs -pyscipopt.recipes.nonlinear.Model.getLinearConsIndicator -pyscipopt.recipes.nonlinear.Model.getLocalEstimate -pyscipopt.recipes.nonlinear.Model.getLowerbound -pyscipopt.recipes.nonlinear.Model.getMajorVersion -pyscipopt.recipes.nonlinear.Model.getMaxDepth -pyscipopt.recipes.nonlinear.Model.getMinorVersion -pyscipopt.recipes.nonlinear.Model.getNBestSolsFound -pyscipopt.recipes.nonlinear.Model.getNBinVars -pyscipopt.recipes.nonlinear.Model.getNChildren -pyscipopt.recipes.nonlinear.Model.getNConss -pyscipopt.recipes.nonlinear.Model.getNContVars -pyscipopt.recipes.nonlinear.Model.getNCountedSols -pyscipopt.recipes.nonlinear.Model.getNCuts -pyscipopt.recipes.nonlinear.Model.getNCutsApplied -pyscipopt.recipes.nonlinear.Model.getNFeasibleLeaves -pyscipopt.recipes.nonlinear.Model.getNImplVars -pyscipopt.recipes.nonlinear.Model.getNInfeasibleLeaves -pyscipopt.recipes.nonlinear.Model.getNIntVars -pyscipopt.recipes.nonlinear.Model.getNLPBranchCands -pyscipopt.recipes.nonlinear.Model.getNLPCols -pyscipopt.recipes.nonlinear.Model.getNLPIterations -pyscipopt.recipes.nonlinear.Model.getNLPRows -pyscipopt.recipes.nonlinear.Model.getNLPs -pyscipopt.recipes.nonlinear.Model.getNLeaves -pyscipopt.recipes.nonlinear.Model.getNLimSolsFound -pyscipopt.recipes.nonlinear.Model.getNNlRows -pyscipopt.recipes.nonlinear.Model.getNNodeLPIterations -pyscipopt.recipes.nonlinear.Model.getNNodes -pyscipopt.recipes.nonlinear.Model.getNReaders -pyscipopt.recipes.nonlinear.Model.getNSepaRounds -pyscipopt.recipes.nonlinear.Model.getNSiblings -pyscipopt.recipes.nonlinear.Model.getNSols -pyscipopt.recipes.nonlinear.Model.getNSolsFound -pyscipopt.recipes.nonlinear.Model.getNStrongbranchLPIterations -pyscipopt.recipes.nonlinear.Model.getNTotalNodes -pyscipopt.recipes.nonlinear.Model.getNVars -pyscipopt.recipes.nonlinear.Model.getNVarsAnd -pyscipopt.recipes.nonlinear.Model.getNlRowActivityBounds -pyscipopt.recipes.nonlinear.Model.getNlRowSolActivity -pyscipopt.recipes.nonlinear.Model.getNlRowSolFeasibility -pyscipopt.recipes.nonlinear.Model.getNlRows -pyscipopt.recipes.nonlinear.Model.getObjVal -pyscipopt.recipes.nonlinear.Model.getObjective -pyscipopt.recipes.nonlinear.Model.getObjectiveSense -pyscipopt.recipes.nonlinear.Model.getObjlimit -pyscipopt.recipes.nonlinear.Model.getObjoffset -pyscipopt.recipes.nonlinear.Model.getOpenNodes -pyscipopt.recipes.nonlinear.Model.getParam -pyscipopt.recipes.nonlinear.Model.getParams -pyscipopt.recipes.nonlinear.Model.getPlungeDepth -pyscipopt.recipes.nonlinear.Model.getPresolvingTime -pyscipopt.recipes.nonlinear.Model.getPrimalRay -pyscipopt.recipes.nonlinear.Model.getPrimalRayVal -pyscipopt.recipes.nonlinear.Model.getPrimalbound -pyscipopt.recipes.nonlinear.Model.getPrioChild -pyscipopt.recipes.nonlinear.Model.getPrioSibling -pyscipopt.recipes.nonlinear.Model.getProbName -pyscipopt.recipes.nonlinear.Model.getProbingDepth -pyscipopt.recipes.nonlinear.Model.getPseudoBranchCands -pyscipopt.recipes.nonlinear.Model.getReadingTime -pyscipopt.recipes.nonlinear.Model.getResultantAnd -pyscipopt.recipes.nonlinear.Model.getRhs -pyscipopt.recipes.nonlinear.Model.getRowActivity -pyscipopt.recipes.nonlinear.Model.getRowDualSol -pyscipopt.recipes.nonlinear.Model.getRowLPActivity -pyscipopt.recipes.nonlinear.Model.getRowLinear -pyscipopt.recipes.nonlinear.Model.getRowNumIntCols -pyscipopt.recipes.nonlinear.Model.getRowObjParallelism -pyscipopt.recipes.nonlinear.Model.getRowParallelism -pyscipopt.recipes.nonlinear.Model.getSiblings -pyscipopt.recipes.nonlinear.Model.getSlack -pyscipopt.recipes.nonlinear.Model.getSlackVarIndicator -pyscipopt.recipes.nonlinear.Model.getSolObjVal -pyscipopt.recipes.nonlinear.Model.getSolTime -pyscipopt.recipes.nonlinear.Model.getSolVal -pyscipopt.recipes.nonlinear.Model.getSols -pyscipopt.recipes.nonlinear.Model.getSolvingTime -pyscipopt.recipes.nonlinear.Model.getStage -pyscipopt.recipes.nonlinear.Model.getStageName -pyscipopt.recipes.nonlinear.Model.getStatus -pyscipopt.recipes.nonlinear.Model.getTechVersion -pyscipopt.recipes.nonlinear.Model.getTermsQuadratic -pyscipopt.recipes.nonlinear.Model.getTotalTime -pyscipopt.recipes.nonlinear.Model.getTransformedCons -pyscipopt.recipes.nonlinear.Model.getTransformedVar -pyscipopt.recipes.nonlinear.Model.getTreesizeEstimation -pyscipopt.recipes.nonlinear.Model.getVal -pyscipopt.recipes.nonlinear.Model.getValsLinear -pyscipopt.recipes.nonlinear.Model.getVarDict -pyscipopt.recipes.nonlinear.Model.getVarLbDive -pyscipopt.recipes.nonlinear.Model.getVarPseudocost -pyscipopt.recipes.nonlinear.Model.getVarPseudocostScore -pyscipopt.recipes.nonlinear.Model.getVarRedcost -pyscipopt.recipes.nonlinear.Model.getVarStrongbranch -pyscipopt.recipes.nonlinear.Model.getVarStrongbranchLast -pyscipopt.recipes.nonlinear.Model.getVarStrongbranchNode -pyscipopt.recipes.nonlinear.Model.getVarUbDive -pyscipopt.recipes.nonlinear.Model.getVars -pyscipopt.recipes.nonlinear.Model.getVarsAnd -pyscipopt.recipes.nonlinear.Model.getWeightsKnapsack -pyscipopt.recipes.nonlinear.Model.hasPrimalRay -pyscipopt.recipes.nonlinear.Model.hideOutput -pyscipopt.recipes.nonlinear.Model.inProbing -pyscipopt.recipes.nonlinear.Model.inRepropagation -pyscipopt.recipes.nonlinear.Model.includeBenders -pyscipopt.recipes.nonlinear.Model.includeBendersDefaultCuts -pyscipopt.recipes.nonlinear.Model.includeBenderscut -pyscipopt.recipes.nonlinear.Model.includeBranchrule -pyscipopt.recipes.nonlinear.Model.includeConshdlr -pyscipopt.recipes.nonlinear.Model.includeCutsel -pyscipopt.recipes.nonlinear.Model.includeDefaultPlugins -pyscipopt.recipes.nonlinear.Model.includeEventhdlr -pyscipopt.recipes.nonlinear.Model.includeHeur -pyscipopt.recipes.nonlinear.Model.includeIISfinder -pyscipopt.recipes.nonlinear.Model.includeNodesel -pyscipopt.recipes.nonlinear.Model.includePresol -pyscipopt.recipes.nonlinear.Model.includePricer -pyscipopt.recipes.nonlinear.Model.includeProp -pyscipopt.recipes.nonlinear.Model.includeReader -pyscipopt.recipes.nonlinear.Model.includeRelax -pyscipopt.recipes.nonlinear.Model.includeSepa -pyscipopt.recipes.nonlinear.Model.infinity -pyscipopt.recipes.nonlinear.Model.initBendersDefault -pyscipopt.recipes.nonlinear.Model.interruptSolve -pyscipopt.recipes.nonlinear.Model.isAndConsSorted -pyscipopt.recipes.nonlinear.Model.isCutEfficacious -pyscipopt.recipes.nonlinear.Model.isEQ -pyscipopt.recipes.nonlinear.Model.isExact -pyscipopt.recipes.nonlinear.Model.isFeasEQ -pyscipopt.recipes.nonlinear.Model.isFeasGE -pyscipopt.recipes.nonlinear.Model.isFeasGT -pyscipopt.recipes.nonlinear.Model.isFeasIntegral -pyscipopt.recipes.nonlinear.Model.isFeasLE -pyscipopt.recipes.nonlinear.Model.isFeasLT -pyscipopt.recipes.nonlinear.Model.isFeasNegative -pyscipopt.recipes.nonlinear.Model.isFeasPositive -pyscipopt.recipes.nonlinear.Model.isFeasZero -pyscipopt.recipes.nonlinear.Model.isGE -pyscipopt.recipes.nonlinear.Model.isGT -pyscipopt.recipes.nonlinear.Model.isHugeValue -pyscipopt.recipes.nonlinear.Model.isInfinity -pyscipopt.recipes.nonlinear.Model.isLE -pyscipopt.recipes.nonlinear.Model.isLPSolBasic -pyscipopt.recipes.nonlinear.Model.isLT -pyscipopt.recipes.nonlinear.Model.isNLPConstructed -pyscipopt.recipes.nonlinear.Model.isNegative -pyscipopt.recipes.nonlinear.Model.isObjChangedProbing -pyscipopt.recipes.nonlinear.Model.isPositive -pyscipopt.recipes.nonlinear.Model.isZero -pyscipopt.recipes.nonlinear.Model.lpiGetIterations -pyscipopt.recipes.nonlinear.Model.markDoNotAggrVar -pyscipopt.recipes.nonlinear.Model.markDoNotMultaggrVar -pyscipopt.recipes.nonlinear.Model.newProbingNode -pyscipopt.recipes.nonlinear.Model.optimize -pyscipopt.recipes.nonlinear.Model.optimizeNogil -pyscipopt.recipes.nonlinear.Model.presolve -pyscipopt.recipes.nonlinear.Model.printBestSol -pyscipopt.recipes.nonlinear.Model.printCons -pyscipopt.recipes.nonlinear.Model.printExternalCodeVersions -pyscipopt.recipes.nonlinear.Model.printNlRow -pyscipopt.recipes.nonlinear.Model.printProblem -pyscipopt.recipes.nonlinear.Model.printRow -pyscipopt.recipes.nonlinear.Model.printSol -pyscipopt.recipes.nonlinear.Model.printStatistics -pyscipopt.recipes.nonlinear.Model.printStatisticsJson -pyscipopt.recipes.nonlinear.Model.printVersion -pyscipopt.recipes.nonlinear.Model.propagateProbing -pyscipopt.recipes.nonlinear.Model.readParams -pyscipopt.recipes.nonlinear.Model.readProblem -pyscipopt.recipes.nonlinear.Model.readSol -pyscipopt.recipes.nonlinear.Model.readSolFile -pyscipopt.recipes.nonlinear.Model.redirectOutput -pyscipopt.recipes.nonlinear.Model.relax -pyscipopt.recipes.nonlinear.Model.releaseRow -pyscipopt.recipes.nonlinear.Model.repropagateNode -pyscipopt.recipes.nonlinear.Model.resetParam -pyscipopt.recipes.nonlinear.Model.resetParams -pyscipopt.recipes.nonlinear.Model.restartSolve -pyscipopt.recipes.nonlinear.Model.separateSol -pyscipopt.recipes.nonlinear.Model.setBendersSubproblemIsConvex -pyscipopt.recipes.nonlinear.Model.setBoolParam -pyscipopt.recipes.nonlinear.Model.setCharParam -pyscipopt.recipes.nonlinear.Model.setCheck -pyscipopt.recipes.nonlinear.Model.setEmphasis -pyscipopt.recipes.nonlinear.Model.setEnforced -pyscipopt.recipes.nonlinear.Model.setHeurTiming -pyscipopt.recipes.nonlinear.Model.setHeuristics -pyscipopt.recipes.nonlinear.Model.setInitial -pyscipopt.recipes.nonlinear.Model.setIntParam -pyscipopt.recipes.nonlinear.Model.setLogfile -pyscipopt.recipes.nonlinear.Model.setLongintParam -pyscipopt.recipes.nonlinear.Model.setMaximize -pyscipopt.recipes.nonlinear.Model.setMinimize -pyscipopt.recipes.nonlinear.Model.setModifiable -pyscipopt.recipes.nonlinear.Model.setObjIntegral -pyscipopt.recipes.nonlinear.Model.setObjective -pyscipopt.recipes.nonlinear.Model.setObjlimit -pyscipopt.recipes.nonlinear.Model.setParam -pyscipopt.recipes.nonlinear.Model.setParams -pyscipopt.recipes.nonlinear.Model.setParamsCountsols -pyscipopt.recipes.nonlinear.Model.setPresolve -pyscipopt.recipes.nonlinear.Model.setProbName -pyscipopt.recipes.nonlinear.Model.setRealParam -pyscipopt.recipes.nonlinear.Model.setRelaxSolVal -pyscipopt.recipes.nonlinear.Model.setRemovable -pyscipopt.recipes.nonlinear.Model.setSeparating -pyscipopt.recipes.nonlinear.Model.setSolVal -pyscipopt.recipes.nonlinear.Model.setStringParam -pyscipopt.recipes.nonlinear.Model.setupBendersSubproblem -pyscipopt.recipes.nonlinear.Model.solveBendersSubproblem -pyscipopt.recipes.nonlinear.Model.solveConcurrent -pyscipopt.recipes.nonlinear.Model.solveDiveLP -pyscipopt.recipes.nonlinear.Model.solveProbingLP -pyscipopt.recipes.nonlinear.Model.sortAndCons -pyscipopt.recipes.nonlinear.Model.startDive -pyscipopt.recipes.nonlinear.Model.startProbing -pyscipopt.recipes.nonlinear.Model.startStrongbranch -pyscipopt.recipes.nonlinear.Model.tightenVarLb -pyscipopt.recipes.nonlinear.Model.tightenVarLbGlobal -pyscipopt.recipes.nonlinear.Model.tightenVarUb -pyscipopt.recipes.nonlinear.Model.tightenVarUbGlobal -pyscipopt.recipes.nonlinear.Model.to_ptr -pyscipopt.recipes.nonlinear.Model.translateSubSol -pyscipopt.recipes.nonlinear.Model.trySol -pyscipopt.recipes.nonlinear.Model.updateBendersLowerbounds -pyscipopt.recipes.nonlinear.Model.updateNodeLowerbound -pyscipopt.recipes.nonlinear.Model.updateVarPseudocost -pyscipopt.recipes.nonlinear.Model.version -pyscipopt.recipes.nonlinear.Model.writeBestSol -pyscipopt.recipes.nonlinear.Model.writeBestTransSol -pyscipopt.recipes.nonlinear.Model.writeLP -pyscipopt.recipes.nonlinear.Model.writeMIP -pyscipopt.recipes.nonlinear.Model.writeName -pyscipopt.recipes.nonlinear.Model.writeParams -pyscipopt.recipes.nonlinear.Model.writeProblem -pyscipopt.recipes.nonlinear.Model.writeSol -pyscipopt.recipes.nonlinear.Model.writeStatistics -pyscipopt.recipes.nonlinear.Model.writeStatisticsJson -pyscipopt.recipes.nonlinear.Model.writeTransSol -pyscipopt.recipes.piecewise.Constraint -pyscipopt.recipes.piecewise.Constraint.__init__ -pyscipopt.recipes.piecewise.Constraint.getConshdlrName -pyscipopt.recipes.piecewise.Constraint.isActive -pyscipopt.recipes.piecewise.Constraint.isChecked -pyscipopt.recipes.piecewise.Constraint.isDynamic -pyscipopt.recipes.piecewise.Constraint.isEnforced -pyscipopt.recipes.piecewise.Constraint.isInitial -pyscipopt.recipes.piecewise.Constraint.isKnapsack -pyscipopt.recipes.piecewise.Constraint.isLinear -pyscipopt.recipes.piecewise.Constraint.isLinearType -pyscipopt.recipes.piecewise.Constraint.isLocal -pyscipopt.recipes.piecewise.Constraint.isModifiable -pyscipopt.recipes.piecewise.Constraint.isNonlinear -pyscipopt.recipes.piecewise.Constraint.isOriginal -pyscipopt.recipes.piecewise.Constraint.isPropagated -pyscipopt.recipes.piecewise.Constraint.isRemovable -pyscipopt.recipes.piecewise.Constraint.isSeparated -pyscipopt.recipes.piecewise.Constraint.isStickingAtNode -pyscipopt.recipes.piecewise.Model -pyscipopt.recipes.piecewise.Model._createConsGenNonlinear -pyscipopt.recipes.piecewise.Model._createConsLinear -pyscipopt.recipes.piecewise.Model._createConsNonlinear -pyscipopt.recipes.piecewise.Model._createConsQuadratic -pyscipopt.recipes.piecewise.Model._getStageNames -pyscipopt.recipes.piecewise.Model.activateBenders -pyscipopt.recipes.piecewise.Model.addBendersSubproblem -pyscipopt.recipes.piecewise.Model.addCoefKnapsack -pyscipopt.recipes.piecewise.Model.addCoefLinear -pyscipopt.recipes.piecewise.Model.addCons -pyscipopt.recipes.piecewise.Model.addConsAnd -pyscipopt.recipes.piecewise.Model.addConsCardinality -pyscipopt.recipes.piecewise.Model.addConsCoeff -pyscipopt.recipes.piecewise.Model.addConsDisjunction -pyscipopt.recipes.piecewise.Model.addConsElemDisjunction -pyscipopt.recipes.piecewise.Model.addConsIndicator -pyscipopt.recipes.piecewise.Model.addConsKnapsack -pyscipopt.recipes.piecewise.Model.addConsLocal -pyscipopt.recipes.piecewise.Model.addConsNode -pyscipopt.recipes.piecewise.Model.addConsOr -pyscipopt.recipes.piecewise.Model.addConsSOS1 -pyscipopt.recipes.piecewise.Model.addConsSOS2 -pyscipopt.recipes.piecewise.Model.addConsXor -pyscipopt.recipes.piecewise.Model.addConss -pyscipopt.recipes.piecewise.Model.addCut -pyscipopt.recipes.piecewise.Model.addExprNonlinear -pyscipopt.recipes.piecewise.Model.addMatrixCons -pyscipopt.recipes.piecewise.Model.addMatrixConsIndicator -pyscipopt.recipes.piecewise.Model.addMatrixVar -pyscipopt.recipes.piecewise.Model.addObjoffset -pyscipopt.recipes.piecewise.Model.addPoolCut -pyscipopt.recipes.piecewise.Model.addPyCons -pyscipopt.recipes.piecewise.Model.addRowDive -pyscipopt.recipes.piecewise.Model.addRowExact -pyscipopt.recipes.piecewise.Model.addSol -pyscipopt.recipes.piecewise.Model.addVar -pyscipopt.recipes.piecewise.Model.addVarLocks -pyscipopt.recipes.piecewise.Model.addVarLocksType -pyscipopt.recipes.piecewise.Model.addVarSOS1 -pyscipopt.recipes.piecewise.Model.addVarSOS2 -pyscipopt.recipes.piecewise.Model.addVarToRow -pyscipopt.recipes.piecewise.Model.allColsInLP -pyscipopt.recipes.piecewise.Model.allowNegSlackExact -pyscipopt.recipes.piecewise.Model.appendVarSOS1 -pyscipopt.recipes.piecewise.Model.appendVarSOS2 -pyscipopt.recipes.piecewise.Model.applyCutsProbing -pyscipopt.recipes.piecewise.Model.attachEventHandlerCallback -pyscipopt.recipes.piecewise.Model.backtrackProbing -pyscipopt.recipes.piecewise.Model.branchLPExact -pyscipopt.recipes.piecewise.Model.branchVar -pyscipopt.recipes.piecewise.Model.branchVarVal -pyscipopt.recipes.piecewise.Model.cacheRowExtensions -pyscipopt.recipes.piecewise.Model.calcChildEstimate -pyscipopt.recipes.piecewise.Model.calcNodeselPriority -pyscipopt.recipes.piecewise.Model.catchEvent -pyscipopt.recipes.piecewise.Model.catchRowEvent -pyscipopt.recipes.piecewise.Model.catchVarEvent -pyscipopt.recipes.piecewise.Model.checkBendersSubproblemOptimality -pyscipopt.recipes.piecewise.Model.checkQuadraticNonlinear -pyscipopt.recipes.piecewise.Model.checkSol -pyscipopt.recipes.piecewise.Model.chgCapacityKnapsack -pyscipopt.recipes.piecewise.Model.chgCoefLinear -pyscipopt.recipes.piecewise.Model.chgLhs -pyscipopt.recipes.piecewise.Model.chgReoptObjective -pyscipopt.recipes.piecewise.Model.chgRhs -pyscipopt.recipes.piecewise.Model.chgRowLhsDive -pyscipopt.recipes.piecewise.Model.chgRowRhsDive -pyscipopt.recipes.piecewise.Model.chgVarBranchPriority -pyscipopt.recipes.piecewise.Model.chgVarLb -pyscipopt.recipes.piecewise.Model.chgVarLbDive -pyscipopt.recipes.piecewise.Model.chgVarLbGlobal -pyscipopt.recipes.piecewise.Model.chgVarLbNode -pyscipopt.recipes.piecewise.Model.chgVarLbProbing -pyscipopt.recipes.piecewise.Model.chgVarObjDive -pyscipopt.recipes.piecewise.Model.chgVarObjProbing -pyscipopt.recipes.piecewise.Model.chgVarType -pyscipopt.recipes.piecewise.Model.chgVarUb -pyscipopt.recipes.piecewise.Model.chgVarUbDive -pyscipopt.recipes.piecewise.Model.chgVarUbGlobal -pyscipopt.recipes.piecewise.Model.chgVarUbNode -pyscipopt.recipes.piecewise.Model.chgVarUbProbing -pyscipopt.recipes.piecewise.Model.computeBestSolSubproblems -pyscipopt.recipes.piecewise.Model.constructLP -pyscipopt.recipes.piecewise.Model.copyLargeNeighborhoodSearch -pyscipopt.recipes.piecewise.Model.count -pyscipopt.recipes.piecewise.Model.createChild -pyscipopt.recipes.piecewise.Model.createCons -pyscipopt.recipes.piecewise.Model.createConsFromExpr -pyscipopt.recipes.piecewise.Model.createEmptyRowSepa -pyscipopt.recipes.piecewise.Model.createEmptyRowUnspec -pyscipopt.recipes.piecewise.Model.createOrigSol -pyscipopt.recipes.piecewise.Model.createPartialSol -pyscipopt.recipes.piecewise.Model.createProbBasic -pyscipopt.recipes.piecewise.Model.createSol -pyscipopt.recipes.piecewise.Model.cutoffNode -pyscipopt.recipes.piecewise.Model.deactivatePricer -pyscipopt.recipes.piecewise.Model.delCoefLinear -pyscipopt.recipes.piecewise.Model.delCons -pyscipopt.recipes.piecewise.Model.delConsLocal -pyscipopt.recipes.piecewise.Model.delVar -pyscipopt.recipes.piecewise.Model.disableDebugSol -pyscipopt.recipes.piecewise.Model.disablePropagation -pyscipopt.recipes.piecewise.Model.dropEvent -pyscipopt.recipes.piecewise.Model.dropRowEvent -pyscipopt.recipes.piecewise.Model.dropVarEvent -pyscipopt.recipes.piecewise.Model.enableDebugSol -pyscipopt.recipes.piecewise.Model.enableExactSolving -pyscipopt.recipes.piecewise.Model.enableReoptimization -pyscipopt.recipes.piecewise.Model.endDive -pyscipopt.recipes.piecewise.Model.endProbing -pyscipopt.recipes.piecewise.Model.endStrongbranch -pyscipopt.recipes.piecewise.Model.epsilon -pyscipopt.recipes.piecewise.Model.feasCeil -pyscipopt.recipes.piecewise.Model.feasFloor -pyscipopt.recipes.piecewise.Model.feasFrac -pyscipopt.recipes.piecewise.Model.feasRound -pyscipopt.recipes.piecewise.Model.feastol -pyscipopt.recipes.piecewise.Model.fixVar -pyscipopt.recipes.piecewise.Model.fixVarProbing -pyscipopt.recipes.piecewise.Model.flushRowExtensions -pyscipopt.recipes.piecewise.Model.frac -pyscipopt.recipes.piecewise.Model.freeBendersSubproblems -pyscipopt.recipes.piecewise.Model.freeProb -pyscipopt.recipes.piecewise.Model.freeReoptSolve -pyscipopt.recipes.piecewise.Model.freeSol -pyscipopt.recipes.piecewise.Model.freeTransform -pyscipopt.recipes.piecewise.Model.from_ptr -pyscipopt.recipes.piecewise.Model.generateIIS -pyscipopt.recipes.piecewise.Model.getActivity -pyscipopt.recipes.piecewise.Model.getBendersAuxiliaryVar -pyscipopt.recipes.piecewise.Model.getBendersSubproblem -pyscipopt.recipes.piecewise.Model.getBendersVar -pyscipopt.recipes.piecewise.Model.getBestChild -pyscipopt.recipes.piecewise.Model.getBestLeaf -pyscipopt.recipes.piecewise.Model.getBestNode -pyscipopt.recipes.piecewise.Model.getBestSibling -pyscipopt.recipes.piecewise.Model.getBestSol -pyscipopt.recipes.piecewise.Model.getBestboundNode -pyscipopt.recipes.piecewise.Model.getBipartiteGraphRepresentation -pyscipopt.recipes.piecewise.Model.getBranchScoreMultiple -pyscipopt.recipes.piecewise.Model.getCapacityKnapsack -pyscipopt.recipes.piecewise.Model.getChildren -pyscipopt.recipes.piecewise.Model.getColRedCost -pyscipopt.recipes.piecewise.Model.getCondition -pyscipopt.recipes.piecewise.Model.getConsNVars -pyscipopt.recipes.piecewise.Model.getConsVals -pyscipopt.recipes.piecewise.Model.getConsVars -pyscipopt.recipes.piecewise.Model.getConss -pyscipopt.recipes.piecewise.Model.getCurrentNode -pyscipopt.recipes.piecewise.Model.getCutEfficacy -pyscipopt.recipes.piecewise.Model.getCutLPSolCutoffDistance -pyscipopt.recipes.piecewise.Model.getCutoffbound -pyscipopt.recipes.piecewise.Model.getDepth -pyscipopt.recipes.piecewise.Model.getDualMultiplier -pyscipopt.recipes.piecewise.Model.getDualSolVal -pyscipopt.recipes.piecewise.Model.getDualbound -pyscipopt.recipes.piecewise.Model.getDualboundRoot -pyscipopt.recipes.piecewise.Model.getDualfarkasKnapsack -pyscipopt.recipes.piecewise.Model.getDualfarkasLinear -pyscipopt.recipes.piecewise.Model.getDualsolKnapsack -pyscipopt.recipes.piecewise.Model.getDualsolLinear -pyscipopt.recipes.piecewise.Model.getGap -pyscipopt.recipes.piecewise.Model.getHeurTiming -pyscipopt.recipes.piecewise.Model.getIIS -pyscipopt.recipes.piecewise.Model.getLPBInvARow -pyscipopt.recipes.piecewise.Model.getLPBInvRow -pyscipopt.recipes.piecewise.Model.getLPBasisInd -pyscipopt.recipes.piecewise.Model.getLPBranchCands -pyscipopt.recipes.piecewise.Model.getLPColsData -pyscipopt.recipes.piecewise.Model.getLPObjVal -pyscipopt.recipes.piecewise.Model.getLPRowsData -pyscipopt.recipes.piecewise.Model.getLPSolstat -pyscipopt.recipes.piecewise.Model.getLeaves -pyscipopt.recipes.piecewise.Model.getLhs -pyscipopt.recipes.piecewise.Model.getLinearConsIndicator -pyscipopt.recipes.piecewise.Model.getLocalEstimate -pyscipopt.recipes.piecewise.Model.getLowerbound -pyscipopt.recipes.piecewise.Model.getMajorVersion -pyscipopt.recipes.piecewise.Model.getMaxDepth -pyscipopt.recipes.piecewise.Model.getMinorVersion -pyscipopt.recipes.piecewise.Model.getNBestSolsFound -pyscipopt.recipes.piecewise.Model.getNBinVars -pyscipopt.recipes.piecewise.Model.getNChildren -pyscipopt.recipes.piecewise.Model.getNConss -pyscipopt.recipes.piecewise.Model.getNContVars -pyscipopt.recipes.piecewise.Model.getNCountedSols -pyscipopt.recipes.piecewise.Model.getNCuts -pyscipopt.recipes.piecewise.Model.getNCutsApplied -pyscipopt.recipes.piecewise.Model.getNFeasibleLeaves -pyscipopt.recipes.piecewise.Model.getNImplVars -pyscipopt.recipes.piecewise.Model.getNInfeasibleLeaves -pyscipopt.recipes.piecewise.Model.getNIntVars -pyscipopt.recipes.piecewise.Model.getNLPBranchCands -pyscipopt.recipes.piecewise.Model.getNLPCols -pyscipopt.recipes.piecewise.Model.getNLPIterations -pyscipopt.recipes.piecewise.Model.getNLPRows -pyscipopt.recipes.piecewise.Model.getNLPs -pyscipopt.recipes.piecewise.Model.getNLeaves -pyscipopt.recipes.piecewise.Model.getNLimSolsFound -pyscipopt.recipes.piecewise.Model.getNNlRows -pyscipopt.recipes.piecewise.Model.getNNodeLPIterations -pyscipopt.recipes.piecewise.Model.getNNodes -pyscipopt.recipes.piecewise.Model.getNReaders -pyscipopt.recipes.piecewise.Model.getNSepaRounds -pyscipopt.recipes.piecewise.Model.getNSiblings -pyscipopt.recipes.piecewise.Model.getNSols -pyscipopt.recipes.piecewise.Model.getNSolsFound -pyscipopt.recipes.piecewise.Model.getNStrongbranchLPIterations -pyscipopt.recipes.piecewise.Model.getNTotalNodes -pyscipopt.recipes.piecewise.Model.getNVars -pyscipopt.recipes.piecewise.Model.getNVarsAnd -pyscipopt.recipes.piecewise.Model.getNlRowActivityBounds -pyscipopt.recipes.piecewise.Model.getNlRowSolActivity -pyscipopt.recipes.piecewise.Model.getNlRowSolFeasibility -pyscipopt.recipes.piecewise.Model.getNlRows -pyscipopt.recipes.piecewise.Model.getObjVal -pyscipopt.recipes.piecewise.Model.getObjective -pyscipopt.recipes.piecewise.Model.getObjectiveSense -pyscipopt.recipes.piecewise.Model.getObjlimit -pyscipopt.recipes.piecewise.Model.getObjoffset -pyscipopt.recipes.piecewise.Model.getOpenNodes -pyscipopt.recipes.piecewise.Model.getParam -pyscipopt.recipes.piecewise.Model.getParams -pyscipopt.recipes.piecewise.Model.getPlungeDepth -pyscipopt.recipes.piecewise.Model.getPresolvingTime -pyscipopt.recipes.piecewise.Model.getPrimalRay -pyscipopt.recipes.piecewise.Model.getPrimalRayVal -pyscipopt.recipes.piecewise.Model.getPrimalbound -pyscipopt.recipes.piecewise.Model.getPrioChild -pyscipopt.recipes.piecewise.Model.getPrioSibling -pyscipopt.recipes.piecewise.Model.getProbName -pyscipopt.recipes.piecewise.Model.getProbingDepth -pyscipopt.recipes.piecewise.Model.getPseudoBranchCands -pyscipopt.recipes.piecewise.Model.getReadingTime -pyscipopt.recipes.piecewise.Model.getResultantAnd -pyscipopt.recipes.piecewise.Model.getRhs -pyscipopt.recipes.piecewise.Model.getRowActivity -pyscipopt.recipes.piecewise.Model.getRowDualSol -pyscipopt.recipes.piecewise.Model.getRowLPActivity -pyscipopt.recipes.piecewise.Model.getRowLinear -pyscipopt.recipes.piecewise.Model.getRowNumIntCols -pyscipopt.recipes.piecewise.Model.getRowObjParallelism -pyscipopt.recipes.piecewise.Model.getRowParallelism -pyscipopt.recipes.piecewise.Model.getSiblings -pyscipopt.recipes.piecewise.Model.getSlack -pyscipopt.recipes.piecewise.Model.getSlackVarIndicator -pyscipopt.recipes.piecewise.Model.getSolObjVal -pyscipopt.recipes.piecewise.Model.getSolTime -pyscipopt.recipes.piecewise.Model.getSolVal -pyscipopt.recipes.piecewise.Model.getSols -pyscipopt.recipes.piecewise.Model.getSolvingTime -pyscipopt.recipes.piecewise.Model.getStage -pyscipopt.recipes.piecewise.Model.getStageName -pyscipopt.recipes.piecewise.Model.getStatus -pyscipopt.recipes.piecewise.Model.getTechVersion -pyscipopt.recipes.piecewise.Model.getTermsQuadratic -pyscipopt.recipes.piecewise.Model.getTotalTime -pyscipopt.recipes.piecewise.Model.getTransformedCons -pyscipopt.recipes.piecewise.Model.getTransformedVar -pyscipopt.recipes.piecewise.Model.getTreesizeEstimation -pyscipopt.recipes.piecewise.Model.getVal -pyscipopt.recipes.piecewise.Model.getValsLinear -pyscipopt.recipes.piecewise.Model.getVarDict -pyscipopt.recipes.piecewise.Model.getVarLbDive -pyscipopt.recipes.piecewise.Model.getVarPseudocost -pyscipopt.recipes.piecewise.Model.getVarPseudocostScore -pyscipopt.recipes.piecewise.Model.getVarRedcost -pyscipopt.recipes.piecewise.Model.getVarStrongbranch -pyscipopt.recipes.piecewise.Model.getVarStrongbranchLast -pyscipopt.recipes.piecewise.Model.getVarStrongbranchNode -pyscipopt.recipes.piecewise.Model.getVarUbDive -pyscipopt.recipes.piecewise.Model.getVars -pyscipopt.recipes.piecewise.Model.getVarsAnd -pyscipopt.recipes.piecewise.Model.getWeightsKnapsack -pyscipopt.recipes.piecewise.Model.hasPrimalRay -pyscipopt.recipes.piecewise.Model.hideOutput -pyscipopt.recipes.piecewise.Model.inProbing -pyscipopt.recipes.piecewise.Model.inRepropagation -pyscipopt.recipes.piecewise.Model.includeBenders -pyscipopt.recipes.piecewise.Model.includeBendersDefaultCuts -pyscipopt.recipes.piecewise.Model.includeBenderscut -pyscipopt.recipes.piecewise.Model.includeBranchrule -pyscipopt.recipes.piecewise.Model.includeConshdlr -pyscipopt.recipes.piecewise.Model.includeCutsel -pyscipopt.recipes.piecewise.Model.includeDefaultPlugins -pyscipopt.recipes.piecewise.Model.includeEventhdlr -pyscipopt.recipes.piecewise.Model.includeHeur -pyscipopt.recipes.piecewise.Model.includeIISfinder -pyscipopt.recipes.piecewise.Model.includeNodesel -pyscipopt.recipes.piecewise.Model.includePresol -pyscipopt.recipes.piecewise.Model.includePricer -pyscipopt.recipes.piecewise.Model.includeProp -pyscipopt.recipes.piecewise.Model.includeReader -pyscipopt.recipes.piecewise.Model.includeRelax -pyscipopt.recipes.piecewise.Model.includeSepa -pyscipopt.recipes.piecewise.Model.infinity -pyscipopt.recipes.piecewise.Model.initBendersDefault -pyscipopt.recipes.piecewise.Model.interruptSolve -pyscipopt.recipes.piecewise.Model.isAndConsSorted -pyscipopt.recipes.piecewise.Model.isCutEfficacious -pyscipopt.recipes.piecewise.Model.isEQ -pyscipopt.recipes.piecewise.Model.isExact -pyscipopt.recipes.piecewise.Model.isFeasEQ -pyscipopt.recipes.piecewise.Model.isFeasGE -pyscipopt.recipes.piecewise.Model.isFeasGT -pyscipopt.recipes.piecewise.Model.isFeasIntegral -pyscipopt.recipes.piecewise.Model.isFeasLE -pyscipopt.recipes.piecewise.Model.isFeasLT -pyscipopt.recipes.piecewise.Model.isFeasNegative -pyscipopt.recipes.piecewise.Model.isFeasPositive -pyscipopt.recipes.piecewise.Model.isFeasZero -pyscipopt.recipes.piecewise.Model.isGE -pyscipopt.recipes.piecewise.Model.isGT -pyscipopt.recipes.piecewise.Model.isHugeValue -pyscipopt.recipes.piecewise.Model.isInfinity -pyscipopt.recipes.piecewise.Model.isLE -pyscipopt.recipes.piecewise.Model.isLPSolBasic -pyscipopt.recipes.piecewise.Model.isLT -pyscipopt.recipes.piecewise.Model.isNLPConstructed -pyscipopt.recipes.piecewise.Model.isNegative -pyscipopt.recipes.piecewise.Model.isObjChangedProbing -pyscipopt.recipes.piecewise.Model.isPositive -pyscipopt.recipes.piecewise.Model.isZero -pyscipopt.recipes.piecewise.Model.lpiGetIterations -pyscipopt.recipes.piecewise.Model.markDoNotAggrVar -pyscipopt.recipes.piecewise.Model.markDoNotMultaggrVar -pyscipopt.recipes.piecewise.Model.newProbingNode -pyscipopt.recipes.piecewise.Model.optimize -pyscipopt.recipes.piecewise.Model.optimizeNogil -pyscipopt.recipes.piecewise.Model.presolve -pyscipopt.recipes.piecewise.Model.printBestSol -pyscipopt.recipes.piecewise.Model.printCons -pyscipopt.recipes.piecewise.Model.printExternalCodeVersions -pyscipopt.recipes.piecewise.Model.printNlRow -pyscipopt.recipes.piecewise.Model.printProblem -pyscipopt.recipes.piecewise.Model.printRow -pyscipopt.recipes.piecewise.Model.printSol -pyscipopt.recipes.piecewise.Model.printStatistics -pyscipopt.recipes.piecewise.Model.printStatisticsJson -pyscipopt.recipes.piecewise.Model.printVersion -pyscipopt.recipes.piecewise.Model.propagateProbing -pyscipopt.recipes.piecewise.Model.readParams -pyscipopt.recipes.piecewise.Model.readProblem -pyscipopt.recipes.piecewise.Model.readSol -pyscipopt.recipes.piecewise.Model.readSolFile -pyscipopt.recipes.piecewise.Model.redirectOutput -pyscipopt.recipes.piecewise.Model.relax -pyscipopt.recipes.piecewise.Model.releaseRow -pyscipopt.recipes.piecewise.Model.repropagateNode -pyscipopt.recipes.piecewise.Model.resetParam -pyscipopt.recipes.piecewise.Model.resetParams -pyscipopt.recipes.piecewise.Model.restartSolve -pyscipopt.recipes.piecewise.Model.separateSol -pyscipopt.recipes.piecewise.Model.setBendersSubproblemIsConvex -pyscipopt.recipes.piecewise.Model.setBoolParam -pyscipopt.recipes.piecewise.Model.setCharParam -pyscipopt.recipes.piecewise.Model.setCheck -pyscipopt.recipes.piecewise.Model.setEmphasis -pyscipopt.recipes.piecewise.Model.setEnforced -pyscipopt.recipes.piecewise.Model.setHeurTiming -pyscipopt.recipes.piecewise.Model.setHeuristics -pyscipopt.recipes.piecewise.Model.setInitial -pyscipopt.recipes.piecewise.Model.setIntParam -pyscipopt.recipes.piecewise.Model.setLogfile -pyscipopt.recipes.piecewise.Model.setLongintParam -pyscipopt.recipes.piecewise.Model.setMaximize -pyscipopt.recipes.piecewise.Model.setMinimize -pyscipopt.recipes.piecewise.Model.setModifiable -pyscipopt.recipes.piecewise.Model.setObjIntegral -pyscipopt.recipes.piecewise.Model.setObjective -pyscipopt.recipes.piecewise.Model.setObjlimit -pyscipopt.recipes.piecewise.Model.setParam -pyscipopt.recipes.piecewise.Model.setParams -pyscipopt.recipes.piecewise.Model.setParamsCountsols -pyscipopt.recipes.piecewise.Model.setPresolve -pyscipopt.recipes.piecewise.Model.setProbName -pyscipopt.recipes.piecewise.Model.setRealParam -pyscipopt.recipes.piecewise.Model.setRelaxSolVal -pyscipopt.recipes.piecewise.Model.setRemovable -pyscipopt.recipes.piecewise.Model.setSeparating -pyscipopt.recipes.piecewise.Model.setSolVal -pyscipopt.recipes.piecewise.Model.setStringParam -pyscipopt.recipes.piecewise.Model.setupBendersSubproblem -pyscipopt.recipes.piecewise.Model.solveBendersSubproblem -pyscipopt.recipes.piecewise.Model.solveConcurrent -pyscipopt.recipes.piecewise.Model.solveDiveLP -pyscipopt.recipes.piecewise.Model.solveProbingLP -pyscipopt.recipes.piecewise.Model.sortAndCons -pyscipopt.recipes.piecewise.Model.startDive -pyscipopt.recipes.piecewise.Model.startProbing -pyscipopt.recipes.piecewise.Model.startStrongbranch -pyscipopt.recipes.piecewise.Model.tightenVarLb -pyscipopt.recipes.piecewise.Model.tightenVarLbGlobal -pyscipopt.recipes.piecewise.Model.tightenVarUb -pyscipopt.recipes.piecewise.Model.tightenVarUbGlobal -pyscipopt.recipes.piecewise.Model.to_ptr -pyscipopt.recipes.piecewise.Model.translateSubSol -pyscipopt.recipes.piecewise.Model.trySol -pyscipopt.recipes.piecewise.Model.updateBendersLowerbounds -pyscipopt.recipes.piecewise.Model.updateNodeLowerbound -pyscipopt.recipes.piecewise.Model.updateVarPseudocost -pyscipopt.recipes.piecewise.Model.version -pyscipopt.recipes.piecewise.Model.writeBestSol -pyscipopt.recipes.piecewise.Model.writeBestTransSol -pyscipopt.recipes.piecewise.Model.writeLP -pyscipopt.recipes.piecewise.Model.writeMIP -pyscipopt.recipes.piecewise.Model.writeName -pyscipopt.recipes.piecewise.Model.writeParams -pyscipopt.recipes.piecewise.Model.writeProblem -pyscipopt.recipes.piecewise.Model.writeSol -pyscipopt.recipes.piecewise.Model.writeStatistics -pyscipopt.recipes.piecewise.Model.writeStatisticsJson -pyscipopt.recipes.piecewise.Model.writeTransSol -pyscipopt.recipes.piecewise.Variable -pyscipopt.recipes.piecewise.Variable.getAvgSol -pyscipopt.recipes.piecewise.Variable.getCol -pyscipopt.recipes.piecewise.Variable.getImplType -pyscipopt.recipes.piecewise.Variable.getIndex -pyscipopt.recipes.piecewise.Variable.getLPSol -pyscipopt.recipes.piecewise.Variable.getLbGlobal -pyscipopt.recipes.piecewise.Variable.getLbLocal -pyscipopt.recipes.piecewise.Variable.getLbOriginal -pyscipopt.recipes.piecewise.Variable.getNBranchings -pyscipopt.recipes.piecewise.Variable.getNBranchingsCurrentRun -pyscipopt.recipes.piecewise.Variable.getNLocksDown -pyscipopt.recipes.piecewise.Variable.getNLocksDownType -pyscipopt.recipes.piecewise.Variable.getNLocksUp -pyscipopt.recipes.piecewise.Variable.getNLocksUpType -pyscipopt.recipes.piecewise.Variable.getObj -pyscipopt.recipes.piecewise.Variable.getStatus -pyscipopt.recipes.piecewise.Variable.getUbGlobal -pyscipopt.recipes.piecewise.Variable.getUbLocal -pyscipopt.recipes.piecewise.Variable.getUbOriginal -pyscipopt.recipes.piecewise.Variable.isActive -pyscipopt.recipes.piecewise.Variable.isBinary -pyscipopt.recipes.piecewise.Variable.isDeletable -pyscipopt.recipes.piecewise.Variable.isImpliedIntegral -pyscipopt.recipes.piecewise.Variable.isInLP -pyscipopt.recipes.piecewise.Variable.isIntegral -pyscipopt.recipes.piecewise.Variable.isNonImpliedIntegral -pyscipopt.recipes.piecewise.Variable.isOriginal -pyscipopt.recipes.piecewise.Variable.isRelaxationOnly -pyscipopt.recipes.piecewise.Variable.markRelaxationOnly -pyscipopt.recipes.piecewise.Variable.ptr -pyscipopt.recipes.piecewise.Variable.varMayRound -pyscipopt.recipes.piecewise.Variable.vtype -pyscipopt.recipes.primal_dual_evolution.Eventhdlr -pyscipopt.recipes.primal_dual_evolution.Eventhdlr.__init__ -pyscipopt.recipes.primal_dual_evolution.Eventhdlr.eventcopy -pyscipopt.recipes.primal_dual_evolution.Eventhdlr.eventdelete -pyscipopt.recipes.primal_dual_evolution.Eventhdlr.eventexec -pyscipopt.recipes.primal_dual_evolution.Eventhdlr.eventexit -pyscipopt.recipes.primal_dual_evolution.Eventhdlr.eventexitsol -pyscipopt.recipes.primal_dual_evolution.Eventhdlr.eventfree -pyscipopt.recipes.primal_dual_evolution.Eventhdlr.eventinit -pyscipopt.recipes.primal_dual_evolution.Eventhdlr.eventinitsol pyscipopt.recipes.primal_dual_evolution.GapEventhdlr@14 -pyscipopt.recipes.primal_dual_evolution.Model -pyscipopt.recipes.primal_dual_evolution.Model._createConsGenNonlinear -pyscipopt.recipes.primal_dual_evolution.Model._createConsLinear -pyscipopt.recipes.primal_dual_evolution.Model._createConsNonlinear -pyscipopt.recipes.primal_dual_evolution.Model._createConsQuadratic -pyscipopt.recipes.primal_dual_evolution.Model._getStageNames -pyscipopt.recipes.primal_dual_evolution.Model.activateBenders -pyscipopt.recipes.primal_dual_evolution.Model.addBendersSubproblem -pyscipopt.recipes.primal_dual_evolution.Model.addCoefKnapsack -pyscipopt.recipes.primal_dual_evolution.Model.addCoefLinear -pyscipopt.recipes.primal_dual_evolution.Model.addCons -pyscipopt.recipes.primal_dual_evolution.Model.addConsAnd -pyscipopt.recipes.primal_dual_evolution.Model.addConsCardinality -pyscipopt.recipes.primal_dual_evolution.Model.addConsCoeff -pyscipopt.recipes.primal_dual_evolution.Model.addConsDisjunction -pyscipopt.recipes.primal_dual_evolution.Model.addConsElemDisjunction -pyscipopt.recipes.primal_dual_evolution.Model.addConsIndicator -pyscipopt.recipes.primal_dual_evolution.Model.addConsKnapsack -pyscipopt.recipes.primal_dual_evolution.Model.addConsLocal -pyscipopt.recipes.primal_dual_evolution.Model.addConsNode -pyscipopt.recipes.primal_dual_evolution.Model.addConsOr -pyscipopt.recipes.primal_dual_evolution.Model.addConsSOS1 -pyscipopt.recipes.primal_dual_evolution.Model.addConsSOS2 -pyscipopt.recipes.primal_dual_evolution.Model.addConsXor -pyscipopt.recipes.primal_dual_evolution.Model.addConss -pyscipopt.recipes.primal_dual_evolution.Model.addCut -pyscipopt.recipes.primal_dual_evolution.Model.addExprNonlinear -pyscipopt.recipes.primal_dual_evolution.Model.addMatrixCons -pyscipopt.recipes.primal_dual_evolution.Model.addMatrixConsIndicator -pyscipopt.recipes.primal_dual_evolution.Model.addMatrixVar -pyscipopt.recipes.primal_dual_evolution.Model.addObjoffset -pyscipopt.recipes.primal_dual_evolution.Model.addPoolCut -pyscipopt.recipes.primal_dual_evolution.Model.addPyCons -pyscipopt.recipes.primal_dual_evolution.Model.addRowDive -pyscipopt.recipes.primal_dual_evolution.Model.addRowExact -pyscipopt.recipes.primal_dual_evolution.Model.addSol -pyscipopt.recipes.primal_dual_evolution.Model.addVar -pyscipopt.recipes.primal_dual_evolution.Model.addVarLocks -pyscipopt.recipes.primal_dual_evolution.Model.addVarLocksType -pyscipopt.recipes.primal_dual_evolution.Model.addVarSOS1 -pyscipopt.recipes.primal_dual_evolution.Model.addVarSOS2 -pyscipopt.recipes.primal_dual_evolution.Model.addVarToRow -pyscipopt.recipes.primal_dual_evolution.Model.allColsInLP -pyscipopt.recipes.primal_dual_evolution.Model.allowNegSlackExact -pyscipopt.recipes.primal_dual_evolution.Model.appendVarSOS1 -pyscipopt.recipes.primal_dual_evolution.Model.appendVarSOS2 -pyscipopt.recipes.primal_dual_evolution.Model.applyCutsProbing -pyscipopt.recipes.primal_dual_evolution.Model.attachEventHandlerCallback -pyscipopt.recipes.primal_dual_evolution.Model.backtrackProbing -pyscipopt.recipes.primal_dual_evolution.Model.branchLPExact -pyscipopt.recipes.primal_dual_evolution.Model.branchVar -pyscipopt.recipes.primal_dual_evolution.Model.branchVarVal -pyscipopt.recipes.primal_dual_evolution.Model.cacheRowExtensions -pyscipopt.recipes.primal_dual_evolution.Model.calcChildEstimate -pyscipopt.recipes.primal_dual_evolution.Model.calcNodeselPriority -pyscipopt.recipes.primal_dual_evolution.Model.catchEvent -pyscipopt.recipes.primal_dual_evolution.Model.catchRowEvent -pyscipopt.recipes.primal_dual_evolution.Model.catchVarEvent -pyscipopt.recipes.primal_dual_evolution.Model.checkBendersSubproblemOptimality -pyscipopt.recipes.primal_dual_evolution.Model.checkQuadraticNonlinear -pyscipopt.recipes.primal_dual_evolution.Model.checkSol -pyscipopt.recipes.primal_dual_evolution.Model.chgCapacityKnapsack -pyscipopt.recipes.primal_dual_evolution.Model.chgCoefLinear -pyscipopt.recipes.primal_dual_evolution.Model.chgLhs -pyscipopt.recipes.primal_dual_evolution.Model.chgReoptObjective -pyscipopt.recipes.primal_dual_evolution.Model.chgRhs -pyscipopt.recipes.primal_dual_evolution.Model.chgRowLhsDive -pyscipopt.recipes.primal_dual_evolution.Model.chgRowRhsDive -pyscipopt.recipes.primal_dual_evolution.Model.chgVarBranchPriority -pyscipopt.recipes.primal_dual_evolution.Model.chgVarLb -pyscipopt.recipes.primal_dual_evolution.Model.chgVarLbDive -pyscipopt.recipes.primal_dual_evolution.Model.chgVarLbGlobal -pyscipopt.recipes.primal_dual_evolution.Model.chgVarLbNode -pyscipopt.recipes.primal_dual_evolution.Model.chgVarLbProbing -pyscipopt.recipes.primal_dual_evolution.Model.chgVarObjDive -pyscipopt.recipes.primal_dual_evolution.Model.chgVarObjProbing -pyscipopt.recipes.primal_dual_evolution.Model.chgVarType -pyscipopt.recipes.primal_dual_evolution.Model.chgVarUb -pyscipopt.recipes.primal_dual_evolution.Model.chgVarUbDive -pyscipopt.recipes.primal_dual_evolution.Model.chgVarUbGlobal -pyscipopt.recipes.primal_dual_evolution.Model.chgVarUbNode -pyscipopt.recipes.primal_dual_evolution.Model.chgVarUbProbing -pyscipopt.recipes.primal_dual_evolution.Model.computeBestSolSubproblems -pyscipopt.recipes.primal_dual_evolution.Model.constructLP -pyscipopt.recipes.primal_dual_evolution.Model.copyLargeNeighborhoodSearch -pyscipopt.recipes.primal_dual_evolution.Model.count -pyscipopt.recipes.primal_dual_evolution.Model.createChild -pyscipopt.recipes.primal_dual_evolution.Model.createCons -pyscipopt.recipes.primal_dual_evolution.Model.createConsFromExpr -pyscipopt.recipes.primal_dual_evolution.Model.createEmptyRowSepa -pyscipopt.recipes.primal_dual_evolution.Model.createEmptyRowUnspec -pyscipopt.recipes.primal_dual_evolution.Model.createOrigSol -pyscipopt.recipes.primal_dual_evolution.Model.createPartialSol -pyscipopt.recipes.primal_dual_evolution.Model.createProbBasic -pyscipopt.recipes.primal_dual_evolution.Model.createSol -pyscipopt.recipes.primal_dual_evolution.Model.cutoffNode -pyscipopt.recipes.primal_dual_evolution.Model.deactivatePricer -pyscipopt.recipes.primal_dual_evolution.Model.delCoefLinear -pyscipopt.recipes.primal_dual_evolution.Model.delCons -pyscipopt.recipes.primal_dual_evolution.Model.delConsLocal -pyscipopt.recipes.primal_dual_evolution.Model.delVar -pyscipopt.recipes.primal_dual_evolution.Model.disableDebugSol -pyscipopt.recipes.primal_dual_evolution.Model.disablePropagation -pyscipopt.recipes.primal_dual_evolution.Model.dropEvent -pyscipopt.recipes.primal_dual_evolution.Model.dropRowEvent -pyscipopt.recipes.primal_dual_evolution.Model.dropVarEvent -pyscipopt.recipes.primal_dual_evolution.Model.enableDebugSol -pyscipopt.recipes.primal_dual_evolution.Model.enableExactSolving -pyscipopt.recipes.primal_dual_evolution.Model.enableReoptimization -pyscipopt.recipes.primal_dual_evolution.Model.endDive -pyscipopt.recipes.primal_dual_evolution.Model.endProbing -pyscipopt.recipes.primal_dual_evolution.Model.endStrongbranch -pyscipopt.recipes.primal_dual_evolution.Model.epsilon -pyscipopt.recipes.primal_dual_evolution.Model.feasCeil -pyscipopt.recipes.primal_dual_evolution.Model.feasFloor -pyscipopt.recipes.primal_dual_evolution.Model.feasFrac -pyscipopt.recipes.primal_dual_evolution.Model.feasRound -pyscipopt.recipes.primal_dual_evolution.Model.feastol -pyscipopt.recipes.primal_dual_evolution.Model.fixVar -pyscipopt.recipes.primal_dual_evolution.Model.fixVarProbing -pyscipopt.recipes.primal_dual_evolution.Model.flushRowExtensions -pyscipopt.recipes.primal_dual_evolution.Model.frac -pyscipopt.recipes.primal_dual_evolution.Model.freeBendersSubproblems -pyscipopt.recipes.primal_dual_evolution.Model.freeProb -pyscipopt.recipes.primal_dual_evolution.Model.freeReoptSolve -pyscipopt.recipes.primal_dual_evolution.Model.freeSol -pyscipopt.recipes.primal_dual_evolution.Model.freeTransform -pyscipopt.recipes.primal_dual_evolution.Model.from_ptr -pyscipopt.recipes.primal_dual_evolution.Model.generateIIS -pyscipopt.recipes.primal_dual_evolution.Model.getActivity -pyscipopt.recipes.primal_dual_evolution.Model.getBendersAuxiliaryVar -pyscipopt.recipes.primal_dual_evolution.Model.getBendersSubproblem -pyscipopt.recipes.primal_dual_evolution.Model.getBendersVar -pyscipopt.recipes.primal_dual_evolution.Model.getBestChild -pyscipopt.recipes.primal_dual_evolution.Model.getBestLeaf -pyscipopt.recipes.primal_dual_evolution.Model.getBestNode -pyscipopt.recipes.primal_dual_evolution.Model.getBestSibling -pyscipopt.recipes.primal_dual_evolution.Model.getBestSol -pyscipopt.recipes.primal_dual_evolution.Model.getBestboundNode -pyscipopt.recipes.primal_dual_evolution.Model.getBipartiteGraphRepresentation -pyscipopt.recipes.primal_dual_evolution.Model.getBranchScoreMultiple -pyscipopt.recipes.primal_dual_evolution.Model.getCapacityKnapsack -pyscipopt.recipes.primal_dual_evolution.Model.getChildren -pyscipopt.recipes.primal_dual_evolution.Model.getColRedCost -pyscipopt.recipes.primal_dual_evolution.Model.getCondition -pyscipopt.recipes.primal_dual_evolution.Model.getConsNVars -pyscipopt.recipes.primal_dual_evolution.Model.getConsVals -pyscipopt.recipes.primal_dual_evolution.Model.getConsVars -pyscipopt.recipes.primal_dual_evolution.Model.getConss -pyscipopt.recipes.primal_dual_evolution.Model.getCurrentNode -pyscipopt.recipes.primal_dual_evolution.Model.getCutEfficacy -pyscipopt.recipes.primal_dual_evolution.Model.getCutLPSolCutoffDistance -pyscipopt.recipes.primal_dual_evolution.Model.getCutoffbound -pyscipopt.recipes.primal_dual_evolution.Model.getDepth -pyscipopt.recipes.primal_dual_evolution.Model.getDualMultiplier -pyscipopt.recipes.primal_dual_evolution.Model.getDualSolVal -pyscipopt.recipes.primal_dual_evolution.Model.getDualbound -pyscipopt.recipes.primal_dual_evolution.Model.getDualboundRoot -pyscipopt.recipes.primal_dual_evolution.Model.getDualfarkasKnapsack -pyscipopt.recipes.primal_dual_evolution.Model.getDualfarkasLinear -pyscipopt.recipes.primal_dual_evolution.Model.getDualsolKnapsack -pyscipopt.recipes.primal_dual_evolution.Model.getDualsolLinear -pyscipopt.recipes.primal_dual_evolution.Model.getGap -pyscipopt.recipes.primal_dual_evolution.Model.getHeurTiming -pyscipopt.recipes.primal_dual_evolution.Model.getIIS -pyscipopt.recipes.primal_dual_evolution.Model.getLPBInvARow -pyscipopt.recipes.primal_dual_evolution.Model.getLPBInvRow -pyscipopt.recipes.primal_dual_evolution.Model.getLPBasisInd -pyscipopt.recipes.primal_dual_evolution.Model.getLPBranchCands -pyscipopt.recipes.primal_dual_evolution.Model.getLPColsData -pyscipopt.recipes.primal_dual_evolution.Model.getLPObjVal -pyscipopt.recipes.primal_dual_evolution.Model.getLPRowsData -pyscipopt.recipes.primal_dual_evolution.Model.getLPSolstat -pyscipopt.recipes.primal_dual_evolution.Model.getLeaves -pyscipopt.recipes.primal_dual_evolution.Model.getLhs -pyscipopt.recipes.primal_dual_evolution.Model.getLinearConsIndicator -pyscipopt.recipes.primal_dual_evolution.Model.getLocalEstimate -pyscipopt.recipes.primal_dual_evolution.Model.getLowerbound -pyscipopt.recipes.primal_dual_evolution.Model.getMajorVersion -pyscipopt.recipes.primal_dual_evolution.Model.getMaxDepth -pyscipopt.recipes.primal_dual_evolution.Model.getMinorVersion -pyscipopt.recipes.primal_dual_evolution.Model.getNBestSolsFound -pyscipopt.recipes.primal_dual_evolution.Model.getNBinVars -pyscipopt.recipes.primal_dual_evolution.Model.getNChildren -pyscipopt.recipes.primal_dual_evolution.Model.getNConss -pyscipopt.recipes.primal_dual_evolution.Model.getNContVars -pyscipopt.recipes.primal_dual_evolution.Model.getNCountedSols -pyscipopt.recipes.primal_dual_evolution.Model.getNCuts -pyscipopt.recipes.primal_dual_evolution.Model.getNCutsApplied -pyscipopt.recipes.primal_dual_evolution.Model.getNFeasibleLeaves -pyscipopt.recipes.primal_dual_evolution.Model.getNImplVars -pyscipopt.recipes.primal_dual_evolution.Model.getNInfeasibleLeaves -pyscipopt.recipes.primal_dual_evolution.Model.getNIntVars -pyscipopt.recipes.primal_dual_evolution.Model.getNLPBranchCands -pyscipopt.recipes.primal_dual_evolution.Model.getNLPCols -pyscipopt.recipes.primal_dual_evolution.Model.getNLPIterations -pyscipopt.recipes.primal_dual_evolution.Model.getNLPRows -pyscipopt.recipes.primal_dual_evolution.Model.getNLPs -pyscipopt.recipes.primal_dual_evolution.Model.getNLeaves -pyscipopt.recipes.primal_dual_evolution.Model.getNLimSolsFound -pyscipopt.recipes.primal_dual_evolution.Model.getNNlRows -pyscipopt.recipes.primal_dual_evolution.Model.getNNodeLPIterations -pyscipopt.recipes.primal_dual_evolution.Model.getNNodes -pyscipopt.recipes.primal_dual_evolution.Model.getNReaders -pyscipopt.recipes.primal_dual_evolution.Model.getNSepaRounds -pyscipopt.recipes.primal_dual_evolution.Model.getNSiblings -pyscipopt.recipes.primal_dual_evolution.Model.getNSols -pyscipopt.recipes.primal_dual_evolution.Model.getNSolsFound -pyscipopt.recipes.primal_dual_evolution.Model.getNStrongbranchLPIterations -pyscipopt.recipes.primal_dual_evolution.Model.getNTotalNodes -pyscipopt.recipes.primal_dual_evolution.Model.getNVars -pyscipopt.recipes.primal_dual_evolution.Model.getNVarsAnd -pyscipopt.recipes.primal_dual_evolution.Model.getNlRowActivityBounds -pyscipopt.recipes.primal_dual_evolution.Model.getNlRowSolActivity -pyscipopt.recipes.primal_dual_evolution.Model.getNlRowSolFeasibility -pyscipopt.recipes.primal_dual_evolution.Model.getNlRows -pyscipopt.recipes.primal_dual_evolution.Model.getObjVal -pyscipopt.recipes.primal_dual_evolution.Model.getObjective -pyscipopt.recipes.primal_dual_evolution.Model.getObjectiveSense -pyscipopt.recipes.primal_dual_evolution.Model.getObjlimit -pyscipopt.recipes.primal_dual_evolution.Model.getObjoffset -pyscipopt.recipes.primal_dual_evolution.Model.getOpenNodes -pyscipopt.recipes.primal_dual_evolution.Model.getParam -pyscipopt.recipes.primal_dual_evolution.Model.getParams -pyscipopt.recipes.primal_dual_evolution.Model.getPlungeDepth -pyscipopt.recipes.primal_dual_evolution.Model.getPresolvingTime -pyscipopt.recipes.primal_dual_evolution.Model.getPrimalRay -pyscipopt.recipes.primal_dual_evolution.Model.getPrimalRayVal -pyscipopt.recipes.primal_dual_evolution.Model.getPrimalbound -pyscipopt.recipes.primal_dual_evolution.Model.getPrioChild -pyscipopt.recipes.primal_dual_evolution.Model.getPrioSibling -pyscipopt.recipes.primal_dual_evolution.Model.getProbName -pyscipopt.recipes.primal_dual_evolution.Model.getProbingDepth -pyscipopt.recipes.primal_dual_evolution.Model.getPseudoBranchCands -pyscipopt.recipes.primal_dual_evolution.Model.getReadingTime -pyscipopt.recipes.primal_dual_evolution.Model.getResultantAnd -pyscipopt.recipes.primal_dual_evolution.Model.getRhs -pyscipopt.recipes.primal_dual_evolution.Model.getRowActivity -pyscipopt.recipes.primal_dual_evolution.Model.getRowDualSol -pyscipopt.recipes.primal_dual_evolution.Model.getRowLPActivity -pyscipopt.recipes.primal_dual_evolution.Model.getRowLinear -pyscipopt.recipes.primal_dual_evolution.Model.getRowNumIntCols -pyscipopt.recipes.primal_dual_evolution.Model.getRowObjParallelism -pyscipopt.recipes.primal_dual_evolution.Model.getRowParallelism -pyscipopt.recipes.primal_dual_evolution.Model.getSiblings -pyscipopt.recipes.primal_dual_evolution.Model.getSlack -pyscipopt.recipes.primal_dual_evolution.Model.getSlackVarIndicator -pyscipopt.recipes.primal_dual_evolution.Model.getSolObjVal -pyscipopt.recipes.primal_dual_evolution.Model.getSolTime -pyscipopt.recipes.primal_dual_evolution.Model.getSolVal -pyscipopt.recipes.primal_dual_evolution.Model.getSols -pyscipopt.recipes.primal_dual_evolution.Model.getSolvingTime -pyscipopt.recipes.primal_dual_evolution.Model.getStage -pyscipopt.recipes.primal_dual_evolution.Model.getStageName -pyscipopt.recipes.primal_dual_evolution.Model.getStatus -pyscipopt.recipes.primal_dual_evolution.Model.getTechVersion -pyscipopt.recipes.primal_dual_evolution.Model.getTermsQuadratic -pyscipopt.recipes.primal_dual_evolution.Model.getTotalTime -pyscipopt.recipes.primal_dual_evolution.Model.getTransformedCons -pyscipopt.recipes.primal_dual_evolution.Model.getTransformedVar -pyscipopt.recipes.primal_dual_evolution.Model.getTreesizeEstimation -pyscipopt.recipes.primal_dual_evolution.Model.getVal -pyscipopt.recipes.primal_dual_evolution.Model.getValsLinear -pyscipopt.recipes.primal_dual_evolution.Model.getVarDict -pyscipopt.recipes.primal_dual_evolution.Model.getVarLbDive -pyscipopt.recipes.primal_dual_evolution.Model.getVarPseudocost -pyscipopt.recipes.primal_dual_evolution.Model.getVarPseudocostScore -pyscipopt.recipes.primal_dual_evolution.Model.getVarRedcost -pyscipopt.recipes.primal_dual_evolution.Model.getVarStrongbranch -pyscipopt.recipes.primal_dual_evolution.Model.getVarStrongbranchLast -pyscipopt.recipes.primal_dual_evolution.Model.getVarStrongbranchNode -pyscipopt.recipes.primal_dual_evolution.Model.getVarUbDive -pyscipopt.recipes.primal_dual_evolution.Model.getVars -pyscipopt.recipes.primal_dual_evolution.Model.getVarsAnd -pyscipopt.recipes.primal_dual_evolution.Model.getWeightsKnapsack -pyscipopt.recipes.primal_dual_evolution.Model.hasPrimalRay -pyscipopt.recipes.primal_dual_evolution.Model.hideOutput -pyscipopt.recipes.primal_dual_evolution.Model.inProbing -pyscipopt.recipes.primal_dual_evolution.Model.inRepropagation -pyscipopt.recipes.primal_dual_evolution.Model.includeBenders -pyscipopt.recipes.primal_dual_evolution.Model.includeBendersDefaultCuts -pyscipopt.recipes.primal_dual_evolution.Model.includeBenderscut -pyscipopt.recipes.primal_dual_evolution.Model.includeBranchrule -pyscipopt.recipes.primal_dual_evolution.Model.includeConshdlr -pyscipopt.recipes.primal_dual_evolution.Model.includeCutsel -pyscipopt.recipes.primal_dual_evolution.Model.includeDefaultPlugins -pyscipopt.recipes.primal_dual_evolution.Model.includeEventhdlr -pyscipopt.recipes.primal_dual_evolution.Model.includeHeur -pyscipopt.recipes.primal_dual_evolution.Model.includeIISfinder -pyscipopt.recipes.primal_dual_evolution.Model.includeNodesel -pyscipopt.recipes.primal_dual_evolution.Model.includePresol -pyscipopt.recipes.primal_dual_evolution.Model.includePricer -pyscipopt.recipes.primal_dual_evolution.Model.includeProp -pyscipopt.recipes.primal_dual_evolution.Model.includeReader -pyscipopt.recipes.primal_dual_evolution.Model.includeRelax -pyscipopt.recipes.primal_dual_evolution.Model.includeSepa -pyscipopt.recipes.primal_dual_evolution.Model.infinity -pyscipopt.recipes.primal_dual_evolution.Model.initBendersDefault -pyscipopt.recipes.primal_dual_evolution.Model.interruptSolve -pyscipopt.recipes.primal_dual_evolution.Model.isAndConsSorted -pyscipopt.recipes.primal_dual_evolution.Model.isCutEfficacious -pyscipopt.recipes.primal_dual_evolution.Model.isEQ -pyscipopt.recipes.primal_dual_evolution.Model.isExact -pyscipopt.recipes.primal_dual_evolution.Model.isFeasEQ -pyscipopt.recipes.primal_dual_evolution.Model.isFeasGE -pyscipopt.recipes.primal_dual_evolution.Model.isFeasGT -pyscipopt.recipes.primal_dual_evolution.Model.isFeasIntegral -pyscipopt.recipes.primal_dual_evolution.Model.isFeasLE -pyscipopt.recipes.primal_dual_evolution.Model.isFeasLT -pyscipopt.recipes.primal_dual_evolution.Model.isFeasNegative -pyscipopt.recipes.primal_dual_evolution.Model.isFeasPositive -pyscipopt.recipes.primal_dual_evolution.Model.isFeasZero -pyscipopt.recipes.primal_dual_evolution.Model.isGE -pyscipopt.recipes.primal_dual_evolution.Model.isGT -pyscipopt.recipes.primal_dual_evolution.Model.isHugeValue -pyscipopt.recipes.primal_dual_evolution.Model.isInfinity -pyscipopt.recipes.primal_dual_evolution.Model.isLE -pyscipopt.recipes.primal_dual_evolution.Model.isLPSolBasic -pyscipopt.recipes.primal_dual_evolution.Model.isLT -pyscipopt.recipes.primal_dual_evolution.Model.isNLPConstructed -pyscipopt.recipes.primal_dual_evolution.Model.isNegative -pyscipopt.recipes.primal_dual_evolution.Model.isObjChangedProbing -pyscipopt.recipes.primal_dual_evolution.Model.isPositive -pyscipopt.recipes.primal_dual_evolution.Model.isZero -pyscipopt.recipes.primal_dual_evolution.Model.lpiGetIterations -pyscipopt.recipes.primal_dual_evolution.Model.markDoNotAggrVar -pyscipopt.recipes.primal_dual_evolution.Model.markDoNotMultaggrVar -pyscipopt.recipes.primal_dual_evolution.Model.newProbingNode -pyscipopt.recipes.primal_dual_evolution.Model.optimize -pyscipopt.recipes.primal_dual_evolution.Model.optimizeNogil -pyscipopt.recipes.primal_dual_evolution.Model.presolve -pyscipopt.recipes.primal_dual_evolution.Model.printBestSol -pyscipopt.recipes.primal_dual_evolution.Model.printCons -pyscipopt.recipes.primal_dual_evolution.Model.printExternalCodeVersions -pyscipopt.recipes.primal_dual_evolution.Model.printNlRow -pyscipopt.recipes.primal_dual_evolution.Model.printProblem -pyscipopt.recipes.primal_dual_evolution.Model.printRow -pyscipopt.recipes.primal_dual_evolution.Model.printSol -pyscipopt.recipes.primal_dual_evolution.Model.printStatistics -pyscipopt.recipes.primal_dual_evolution.Model.printStatisticsJson -pyscipopt.recipes.primal_dual_evolution.Model.printVersion -pyscipopt.recipes.primal_dual_evolution.Model.propagateProbing -pyscipopt.recipes.primal_dual_evolution.Model.readParams -pyscipopt.recipes.primal_dual_evolution.Model.readProblem -pyscipopt.recipes.primal_dual_evolution.Model.readSol -pyscipopt.recipes.primal_dual_evolution.Model.readSolFile -pyscipopt.recipes.primal_dual_evolution.Model.redirectOutput -pyscipopt.recipes.primal_dual_evolution.Model.relax -pyscipopt.recipes.primal_dual_evolution.Model.releaseRow -pyscipopt.recipes.primal_dual_evolution.Model.repropagateNode -pyscipopt.recipes.primal_dual_evolution.Model.resetParam -pyscipopt.recipes.primal_dual_evolution.Model.resetParams -pyscipopt.recipes.primal_dual_evolution.Model.restartSolve -pyscipopt.recipes.primal_dual_evolution.Model.separateSol -pyscipopt.recipes.primal_dual_evolution.Model.setBendersSubproblemIsConvex -pyscipopt.recipes.primal_dual_evolution.Model.setBoolParam -pyscipopt.recipes.primal_dual_evolution.Model.setCharParam -pyscipopt.recipes.primal_dual_evolution.Model.setCheck -pyscipopt.recipes.primal_dual_evolution.Model.setEmphasis -pyscipopt.recipes.primal_dual_evolution.Model.setEnforced -pyscipopt.recipes.primal_dual_evolution.Model.setHeurTiming -pyscipopt.recipes.primal_dual_evolution.Model.setHeuristics -pyscipopt.recipes.primal_dual_evolution.Model.setInitial -pyscipopt.recipes.primal_dual_evolution.Model.setIntParam -pyscipopt.recipes.primal_dual_evolution.Model.setLogfile -pyscipopt.recipes.primal_dual_evolution.Model.setLongintParam -pyscipopt.recipes.primal_dual_evolution.Model.setMaximize -pyscipopt.recipes.primal_dual_evolution.Model.setMinimize -pyscipopt.recipes.primal_dual_evolution.Model.setModifiable -pyscipopt.recipes.primal_dual_evolution.Model.setObjIntegral -pyscipopt.recipes.primal_dual_evolution.Model.setObjective -pyscipopt.recipes.primal_dual_evolution.Model.setObjlimit -pyscipopt.recipes.primal_dual_evolution.Model.setParam -pyscipopt.recipes.primal_dual_evolution.Model.setParams -pyscipopt.recipes.primal_dual_evolution.Model.setParamsCountsols -pyscipopt.recipes.primal_dual_evolution.Model.setPresolve -pyscipopt.recipes.primal_dual_evolution.Model.setProbName -pyscipopt.recipes.primal_dual_evolution.Model.setRealParam -pyscipopt.recipes.primal_dual_evolution.Model.setRelaxSolVal -pyscipopt.recipes.primal_dual_evolution.Model.setRemovable -pyscipopt.recipes.primal_dual_evolution.Model.setSeparating -pyscipopt.recipes.primal_dual_evolution.Model.setSolVal -pyscipopt.recipes.primal_dual_evolution.Model.setStringParam -pyscipopt.recipes.primal_dual_evolution.Model.setupBendersSubproblem -pyscipopt.recipes.primal_dual_evolution.Model.solveBendersSubproblem -pyscipopt.recipes.primal_dual_evolution.Model.solveConcurrent -pyscipopt.recipes.primal_dual_evolution.Model.solveDiveLP -pyscipopt.recipes.primal_dual_evolution.Model.solveProbingLP -pyscipopt.recipes.primal_dual_evolution.Model.sortAndCons -pyscipopt.recipes.primal_dual_evolution.Model.startDive -pyscipopt.recipes.primal_dual_evolution.Model.startProbing -pyscipopt.recipes.primal_dual_evolution.Model.startStrongbranch -pyscipopt.recipes.primal_dual_evolution.Model.tightenVarLb -pyscipopt.recipes.primal_dual_evolution.Model.tightenVarLbGlobal -pyscipopt.recipes.primal_dual_evolution.Model.tightenVarUb -pyscipopt.recipes.primal_dual_evolution.Model.tightenVarUbGlobal -pyscipopt.recipes.primal_dual_evolution.Model.to_ptr -pyscipopt.recipes.primal_dual_evolution.Model.translateSubSol -pyscipopt.recipes.primal_dual_evolution.Model.trySol -pyscipopt.recipes.primal_dual_evolution.Model.updateBendersLowerbounds -pyscipopt.recipes.primal_dual_evolution.Model.updateNodeLowerbound -pyscipopt.recipes.primal_dual_evolution.Model.updateVarPseudocost -pyscipopt.recipes.primal_dual_evolution.Model.version -pyscipopt.recipes.primal_dual_evolution.Model.writeBestSol -pyscipopt.recipes.primal_dual_evolution.Model.writeBestTransSol -pyscipopt.recipes.primal_dual_evolution.Model.writeLP -pyscipopt.recipes.primal_dual_evolution.Model.writeMIP -pyscipopt.recipes.primal_dual_evolution.Model.writeName -pyscipopt.recipes.primal_dual_evolution.Model.writeParams -pyscipopt.recipes.primal_dual_evolution.Model.writeProblem -pyscipopt.recipes.primal_dual_evolution.Model.writeSol -pyscipopt.recipes.primal_dual_evolution.Model.writeStatistics -pyscipopt.recipes.primal_dual_evolution.Model.writeStatisticsJson -pyscipopt.recipes.primal_dual_evolution.Model.writeTransSol -pyscipopt.recipes.primal_dual_evolution.SCIP_EVENTTYPE.__init__ -pyscipopt.scip.Benders -pyscipopt.scip.Benders.__init__ -pyscipopt.scip.Benders.benderscreatesub -pyscipopt.scip.Benders.bendersexit -pyscipopt.scip.Benders.bendersexitpre -pyscipopt.scip.Benders.bendersexitsol -pyscipopt.scip.Benders.bendersfree -pyscipopt.scip.Benders.bendersfreesub -pyscipopt.scip.Benders.bendersgetvar -pyscipopt.scip.Benders.bendersinit -pyscipopt.scip.Benders.bendersinitpre -pyscipopt.scip.Benders.bendersinitsol -pyscipopt.scip.Benders.benderspostsolve -pyscipopt.scip.Benders.benderspresubsolve -pyscipopt.scip.Benders.benderssolvesub -pyscipopt.scip.Benders.benderssolvesubconvex -pyscipopt.scip.Benderscut -pyscipopt.scip.Benderscut.__init__ -pyscipopt.scip.Benderscut.benderscutexec -pyscipopt.scip.Benderscut.benderscutexit -pyscipopt.scip.Benderscut.benderscutexitsol -pyscipopt.scip.Benderscut.benderscutfree -pyscipopt.scip.Benderscut.benderscutinit -pyscipopt.scip.Benderscut.benderscutinitsol -pyscipopt.scip.BoundChange -pyscipopt.scip.BoundChange.__init__ -pyscipopt.scip.BoundChange.getBoundchgtype -pyscipopt.scip.BoundChange.getBoundtype -pyscipopt.scip.BoundChange.getNewBound -pyscipopt.scip.BoundChange.getVar -pyscipopt.scip.BoundChange.isRedundant -pyscipopt.scip.Branchrule -pyscipopt.scip.Branchrule.__init__ -pyscipopt.scip.Branchrule.branchexecext -pyscipopt.scip.Branchrule.branchexeclp -pyscipopt.scip.Branchrule.branchexecps -pyscipopt.scip.Branchrule.branchexit -pyscipopt.scip.Branchrule.branchexitsol -pyscipopt.scip.Branchrule.branchfree -pyscipopt.scip.Branchrule.branchinit -pyscipopt.scip.Branchrule.branchinitsol -pyscipopt.scip.Column -pyscipopt.scip.Column.__init__ -pyscipopt.scip.Column.getAge -pyscipopt.scip.Column.getBasisStatus -pyscipopt.scip.Column.getLPPos -pyscipopt.scip.Column.getLb -pyscipopt.scip.Column.getObjCoeff -pyscipopt.scip.Column.getPrimsol -pyscipopt.scip.Column.getUb -pyscipopt.scip.Column.getVar -pyscipopt.scip.Column.isIntegral -pyscipopt.scip.ColumnExact -pyscipopt.scip.ColumnExact.__init__ -pyscipopt.scip.Conshdlr -pyscipopt.scip.Conshdlr.__init__ -pyscipopt.scip.Conshdlr.consactive -pyscipopt.scip.Conshdlr.conscheck -pyscipopt.scip.Conshdlr.conscopy -pyscipopt.scip.Conshdlr.consdeactive -pyscipopt.scip.Conshdlr.consdelete -pyscipopt.scip.Conshdlr.consdelvars -pyscipopt.scip.Conshdlr.consdisable -pyscipopt.scip.Conshdlr.consenable -pyscipopt.scip.Conshdlr.consenfolp -pyscipopt.scip.Conshdlr.consenfops -pyscipopt.scip.Conshdlr.consenforelax -pyscipopt.scip.Conshdlr.consexit -pyscipopt.scip.Conshdlr.consexitpre -pyscipopt.scip.Conshdlr.consexitsol -pyscipopt.scip.Conshdlr.consfree -pyscipopt.scip.Conshdlr.consgetdivebdchgs -pyscipopt.scip.Conshdlr.consgetnvars -pyscipopt.scip.Conshdlr.consgetpermsymgraph -pyscipopt.scip.Conshdlr.consgetsignedpermsymgraph -pyscipopt.scip.Conshdlr.consgetvars -pyscipopt.scip.Conshdlr.consinit -pyscipopt.scip.Conshdlr.consinitlp -pyscipopt.scip.Conshdlr.consinitpre -pyscipopt.scip.Conshdlr.consinitsol -pyscipopt.scip.Conshdlr.conslock -pyscipopt.scip.Conshdlr.consparse -pyscipopt.scip.Conshdlr.conspresol -pyscipopt.scip.Conshdlr.consprint -pyscipopt.scip.Conshdlr.consprop -pyscipopt.scip.Conshdlr.consresprop -pyscipopt.scip.Conshdlr.conssepalp -pyscipopt.scip.Conshdlr.conssepasol -pyscipopt.scip.Conshdlr.constrans -pyscipopt.scip.Constant -pyscipopt.scip.Constraint -pyscipopt.scip.Constraint.__init__ -pyscipopt.scip.Constraint.getConshdlrName -pyscipopt.scip.Constraint.isActive -pyscipopt.scip.Constraint.isChecked -pyscipopt.scip.Constraint.isDynamic -pyscipopt.scip.Constraint.isEnforced -pyscipopt.scip.Constraint.isInitial -pyscipopt.scip.Constraint.isKnapsack -pyscipopt.scip.Constraint.isLinear -pyscipopt.scip.Constraint.isLinearType -pyscipopt.scip.Constraint.isLocal -pyscipopt.scip.Constraint.isModifiable -pyscipopt.scip.Constraint.isNonlinear -pyscipopt.scip.Constraint.isOriginal -pyscipopt.scip.Constraint.isPropagated -pyscipopt.scip.Constraint.isRemovable -pyscipopt.scip.Constraint.isSeparated -pyscipopt.scip.Constraint.isStickingAtNode -pyscipopt.scip.Cutsel -pyscipopt.scip.Cutsel.__init__ -pyscipopt.scip.Cutsel.cutselexit -pyscipopt.scip.Cutsel.cutselexitsol -pyscipopt.scip.Cutsel.cutselfree -pyscipopt.scip.Cutsel.cutselinit -pyscipopt.scip.Cutsel.cutselinitsol -pyscipopt.scip.Cutsel.cutselselect -pyscipopt.scip.DomainChanges -pyscipopt.scip.DomainChanges.__init__ -pyscipopt.scip.DomainChanges.getBoundchgs -pyscipopt.scip.Event -pyscipopt.scip.Event.__init__ -pyscipopt.scip.Event._getEventNames -pyscipopt.scip.Event.getName -pyscipopt.scip.Event.getNewBound -pyscipopt.scip.Event.getNode -pyscipopt.scip.Event.getOldBound -pyscipopt.scip.Event.getRow -pyscipopt.scip.Event.getType -pyscipopt.scip.Event.getVar -pyscipopt.scip.Eventhdlr -pyscipopt.scip.Eventhdlr.__init__ -pyscipopt.scip.Eventhdlr.eventcopy -pyscipopt.scip.Eventhdlr.eventdelete -pyscipopt.scip.Eventhdlr.eventexec -pyscipopt.scip.Eventhdlr.eventexit -pyscipopt.scip.Eventhdlr.eventexitsol -pyscipopt.scip.Eventhdlr.eventfree -pyscipopt.scip.Eventhdlr.eventinit -pyscipopt.scip.Eventhdlr.eventinitsol -pyscipopt.scip.Expr -pyscipopt.scip.Expr.__pow__ -pyscipopt.scip.Expr.degree -pyscipopt.scip.Expr.normalize -pyscipopt.scip.ExprCons -pyscipopt.scip.ExprCons.normalize -pyscipopt.scip.GenExpr -pyscipopt.scip.GenExpr.__pow__ -pyscipopt.scip.GenExpr.degree -pyscipopt.scip.GenExpr.getOp -pyscipopt.scip.Heur -pyscipopt.scip.Heur.__init__ -pyscipopt.scip.Heur.heurexec -pyscipopt.scip.Heur.heurexit -pyscipopt.scip.Heur.heurexitsol -pyscipopt.scip.Heur.heurfree -pyscipopt.scip.Heur.heurinit -pyscipopt.scip.Heur.heurinitsol -pyscipopt.scip.IIS -pyscipopt.scip.IIS.__init__ -pyscipopt.scip.IIS.getNNodes -pyscipopt.scip.IIS.getSubscip -pyscipopt.scip.IIS.getTime -pyscipopt.scip.IIS.greedyMakeIrreducible -pyscipopt.scip.IIS.isSubscipInfeasible -pyscipopt.scip.IIS.isSubscipIrreducible -pyscipopt.scip.IIS.setSubscipInfeasible -pyscipopt.scip.IIS.setSubscipIrreducible -pyscipopt.scip.IISfinder -pyscipopt.scip.IISfinder.__init__ -pyscipopt.scip.IISfinder.iisfinderexec -pyscipopt.scip.IISfinder.iisfinderfree -pyscipopt.scip.LP -pyscipopt.scip.LP.addCol -pyscipopt.scip.LP.addCols -pyscipopt.scip.LP.addRow -pyscipopt.scip.LP.addRows -pyscipopt.scip.LP.chgBound -pyscipopt.scip.LP.chgCoef -pyscipopt.scip.LP.chgObj -pyscipopt.scip.LP.chgSide -pyscipopt.scip.LP.clear -pyscipopt.scip.LP.delCols -pyscipopt.scip.LP.delRows -pyscipopt.scip.LP.getActivity -pyscipopt.scip.LP.getBasisInds -pyscipopt.scip.LP.getBounds -pyscipopt.scip.LP.getDual -pyscipopt.scip.LP.getDualRay -pyscipopt.scip.LP.getIntParam -pyscipopt.scip.LP.getNIterations -pyscipopt.scip.LP.getObjVal -pyscipopt.scip.LP.getPrimal -pyscipopt.scip.LP.getPrimalRay -pyscipopt.scip.LP.getRealParam -pyscipopt.scip.LP.getRedcost -pyscipopt.scip.LP.getSides -pyscipopt.scip.LP.infinity -pyscipopt.scip.LP.isDualFeasible -pyscipopt.scip.LP.isInfinity -pyscipopt.scip.LP.isOptimal -pyscipopt.scip.LP.isPrimalFeasible -pyscipopt.scip.LP.ncols -pyscipopt.scip.LP.nrows -pyscipopt.scip.LP.readLP -pyscipopt.scip.LP.setIntParam -pyscipopt.scip.LP.setRealParam -pyscipopt.scip.LP.solve -pyscipopt.scip.LP.writeLP -pyscipopt.scip.MatrixConstraint.getConshdlrName -pyscipopt.scip.MatrixConstraint.isActive -pyscipopt.scip.MatrixConstraint.isChecked -pyscipopt.scip.MatrixConstraint.isDynamic -pyscipopt.scip.MatrixConstraint.isEnforced -pyscipopt.scip.MatrixConstraint.isInitial -pyscipopt.scip.MatrixConstraint.isLinear -pyscipopt.scip.MatrixConstraint.isLocal -pyscipopt.scip.MatrixConstraint.isModifiable -pyscipopt.scip.MatrixConstraint.isNonlinear -pyscipopt.scip.MatrixConstraint.isPropagated -pyscipopt.scip.MatrixConstraint.isRemovable -pyscipopt.scip.MatrixConstraint.isSeparated -pyscipopt.scip.MatrixConstraint.isStickingAtNode -pyscipopt.scip.MatrixExpr.__matmul__ pyscipopt.scip.MatrixExpr.sum -pyscipopt.scip.MatrixVariable.getAvgSol -pyscipopt.scip.MatrixVariable.getCol -pyscipopt.scip.MatrixVariable.getIndex -pyscipopt.scip.MatrixVariable.getLPSol -pyscipopt.scip.MatrixVariable.getLbGlobal -pyscipopt.scip.MatrixVariable.getLbLocal -pyscipopt.scip.MatrixVariable.getLbOriginal -pyscipopt.scip.MatrixVariable.getObj -pyscipopt.scip.MatrixVariable.getUbGlobal -pyscipopt.scip.MatrixVariable.getUbLocal -pyscipopt.scip.MatrixVariable.getUbOriginal -pyscipopt.scip.MatrixVariable.isInLP -pyscipopt.scip.MatrixVariable.varMayRound -pyscipopt.scip.MatrixVariable.vtype -pyscipopt.scip.Model -pyscipopt.scip.Model._createConsGenNonlinear -pyscipopt.scip.Model._createConsLinear -pyscipopt.scip.Model._createConsNonlinear -pyscipopt.scip.Model._createConsQuadratic -pyscipopt.scip.Model._getStageNames -pyscipopt.scip.Model.activateBenders -pyscipopt.scip.Model.addBendersSubproblem -pyscipopt.scip.Model.addCoefKnapsack -pyscipopt.scip.Model.addCoefLinear -pyscipopt.scip.Model.addCons -pyscipopt.scip.Model.addConsAnd -pyscipopt.scip.Model.addConsCardinality -pyscipopt.scip.Model.addConsCoeff -pyscipopt.scip.Model.addConsDisjunction -pyscipopt.scip.Model.addConsElemDisjunction -pyscipopt.scip.Model.addConsIndicator -pyscipopt.scip.Model.addConsKnapsack -pyscipopt.scip.Model.addConsLocal -pyscipopt.scip.Model.addConsNode -pyscipopt.scip.Model.addConsOr -pyscipopt.scip.Model.addConsSOS1 -pyscipopt.scip.Model.addConsSOS2 -pyscipopt.scip.Model.addConsXor -pyscipopt.scip.Model.addConss -pyscipopt.scip.Model.addCut -pyscipopt.scip.Model.addExprNonlinear -pyscipopt.scip.Model.addMatrixCons -pyscipopt.scip.Model.addMatrixConsIndicator -pyscipopt.scip.Model.addMatrixVar -pyscipopt.scip.Model.addObjoffset -pyscipopt.scip.Model.addPoolCut -pyscipopt.scip.Model.addPyCons -pyscipopt.scip.Model.addRowDive -pyscipopt.scip.Model.addRowExact -pyscipopt.scip.Model.addSol -pyscipopt.scip.Model.addVar -pyscipopt.scip.Model.addVarLocks -pyscipopt.scip.Model.addVarLocksType -pyscipopt.scip.Model.addVarSOS1 -pyscipopt.scip.Model.addVarSOS2 -pyscipopt.scip.Model.addVarToRow -pyscipopt.scip.Model.allColsInLP -pyscipopt.scip.Model.allowNegSlackExact -pyscipopt.scip.Model.appendVarSOS1 -pyscipopt.scip.Model.appendVarSOS2 -pyscipopt.scip.Model.applyCutsProbing -pyscipopt.scip.Model.attachEventHandlerCallback -pyscipopt.scip.Model.backtrackProbing -pyscipopt.scip.Model.branchLPExact -pyscipopt.scip.Model.branchVar -pyscipopt.scip.Model.branchVarVal -pyscipopt.scip.Model.cacheRowExtensions -pyscipopt.scip.Model.calcChildEstimate -pyscipopt.scip.Model.calcNodeselPriority -pyscipopt.scip.Model.catchEvent -pyscipopt.scip.Model.catchRowEvent -pyscipopt.scip.Model.catchVarEvent -pyscipopt.scip.Model.checkBendersSubproblemOptimality -pyscipopt.scip.Model.checkQuadraticNonlinear -pyscipopt.scip.Model.checkSol -pyscipopt.scip.Model.chgCapacityKnapsack -pyscipopt.scip.Model.chgCoefLinear -pyscipopt.scip.Model.chgLhs -pyscipopt.scip.Model.chgReoptObjective -pyscipopt.scip.Model.chgRhs -pyscipopt.scip.Model.chgRowLhsDive -pyscipopt.scip.Model.chgRowRhsDive -pyscipopt.scip.Model.chgVarBranchPriority -pyscipopt.scip.Model.chgVarLb -pyscipopt.scip.Model.chgVarLbDive -pyscipopt.scip.Model.chgVarLbGlobal -pyscipopt.scip.Model.chgVarLbNode -pyscipopt.scip.Model.chgVarLbProbing -pyscipopt.scip.Model.chgVarObjDive -pyscipopt.scip.Model.chgVarObjProbing -pyscipopt.scip.Model.chgVarType -pyscipopt.scip.Model.chgVarUb -pyscipopt.scip.Model.chgVarUbDive -pyscipopt.scip.Model.chgVarUbGlobal -pyscipopt.scip.Model.chgVarUbNode -pyscipopt.scip.Model.chgVarUbProbing -pyscipopt.scip.Model.computeBestSolSubproblems -pyscipopt.scip.Model.constructLP -pyscipopt.scip.Model.copyLargeNeighborhoodSearch -pyscipopt.scip.Model.count -pyscipopt.scip.Model.createChild -pyscipopt.scip.Model.createCons -pyscipopt.scip.Model.createConsFromExpr -pyscipopt.scip.Model.createEmptyRowSepa -pyscipopt.scip.Model.createEmptyRowUnspec -pyscipopt.scip.Model.createOrigSol -pyscipopt.scip.Model.createPartialSol -pyscipopt.scip.Model.createProbBasic -pyscipopt.scip.Model.createSol -pyscipopt.scip.Model.cutoffNode -pyscipopt.scip.Model.deactivatePricer -pyscipopt.scip.Model.delCoefLinear -pyscipopt.scip.Model.delCons -pyscipopt.scip.Model.delConsLocal -pyscipopt.scip.Model.delVar -pyscipopt.scip.Model.disableDebugSol -pyscipopt.scip.Model.disablePropagation -pyscipopt.scip.Model.dropEvent -pyscipopt.scip.Model.dropRowEvent -pyscipopt.scip.Model.dropVarEvent -pyscipopt.scip.Model.enableDebugSol -pyscipopt.scip.Model.enableExactSolving -pyscipopt.scip.Model.enableReoptimization -pyscipopt.scip.Model.endDive -pyscipopt.scip.Model.endProbing -pyscipopt.scip.Model.endStrongbranch -pyscipopt.scip.Model.epsilon -pyscipopt.scip.Model.feasCeil -pyscipopt.scip.Model.feasFloor -pyscipopt.scip.Model.feasFrac -pyscipopt.scip.Model.feasRound -pyscipopt.scip.Model.feastol -pyscipopt.scip.Model.fixVar -pyscipopt.scip.Model.fixVarProbing -pyscipopt.scip.Model.flushRowExtensions -pyscipopt.scip.Model.frac -pyscipopt.scip.Model.freeBendersSubproblems -pyscipopt.scip.Model.freeProb -pyscipopt.scip.Model.freeReoptSolve -pyscipopt.scip.Model.freeSol -pyscipopt.scip.Model.freeTransform -pyscipopt.scip.Model.from_ptr -pyscipopt.scip.Model.generateIIS -pyscipopt.scip.Model.getActivity -pyscipopt.scip.Model.getBendersAuxiliaryVar -pyscipopt.scip.Model.getBendersSubproblem -pyscipopt.scip.Model.getBendersVar -pyscipopt.scip.Model.getBestChild -pyscipopt.scip.Model.getBestLeaf -pyscipopt.scip.Model.getBestNode -pyscipopt.scip.Model.getBestSibling -pyscipopt.scip.Model.getBestSol -pyscipopt.scip.Model.getBestboundNode -pyscipopt.scip.Model.getBipartiteGraphRepresentation -pyscipopt.scip.Model.getBranchScoreMultiple -pyscipopt.scip.Model.getCapacityKnapsack -pyscipopt.scip.Model.getChildren -pyscipopt.scip.Model.getColRedCost -pyscipopt.scip.Model.getCondition -pyscipopt.scip.Model.getConsNVars -pyscipopt.scip.Model.getConsVals -pyscipopt.scip.Model.getConsVars -pyscipopt.scip.Model.getConss -pyscipopt.scip.Model.getCurrentNode -pyscipopt.scip.Model.getCutEfficacy -pyscipopt.scip.Model.getCutLPSolCutoffDistance -pyscipopt.scip.Model.getCutoffbound -pyscipopt.scip.Model.getDepth -pyscipopt.scip.Model.getDualMultiplier -pyscipopt.scip.Model.getDualSolVal -pyscipopt.scip.Model.getDualbound -pyscipopt.scip.Model.getDualboundRoot -pyscipopt.scip.Model.getDualfarkasKnapsack -pyscipopt.scip.Model.getDualfarkasLinear -pyscipopt.scip.Model.getDualsolKnapsack -pyscipopt.scip.Model.getDualsolLinear -pyscipopt.scip.Model.getGap -pyscipopt.scip.Model.getHeurTiming -pyscipopt.scip.Model.getIIS -pyscipopt.scip.Model.getLPBInvARow -pyscipopt.scip.Model.getLPBInvRow -pyscipopt.scip.Model.getLPBasisInd -pyscipopt.scip.Model.getLPBranchCands -pyscipopt.scip.Model.getLPColsData -pyscipopt.scip.Model.getLPObjVal -pyscipopt.scip.Model.getLPRowsData -pyscipopt.scip.Model.getLPSolstat -pyscipopt.scip.Model.getLeaves -pyscipopt.scip.Model.getLhs -pyscipopt.scip.Model.getLinearConsIndicator -pyscipopt.scip.Model.getLocalEstimate -pyscipopt.scip.Model.getLowerbound -pyscipopt.scip.Model.getMajorVersion -pyscipopt.scip.Model.getMaxDepth -pyscipopt.scip.Model.getMinorVersion -pyscipopt.scip.Model.getNBestSolsFound -pyscipopt.scip.Model.getNBinVars -pyscipopt.scip.Model.getNChildren -pyscipopt.scip.Model.getNConss -pyscipopt.scip.Model.getNContVars -pyscipopt.scip.Model.getNCountedSols -pyscipopt.scip.Model.getNCuts -pyscipopt.scip.Model.getNCutsApplied -pyscipopt.scip.Model.getNFeasibleLeaves -pyscipopt.scip.Model.getNImplVars -pyscipopt.scip.Model.getNInfeasibleLeaves -pyscipopt.scip.Model.getNIntVars -pyscipopt.scip.Model.getNLPBranchCands -pyscipopt.scip.Model.getNLPCols -pyscipopt.scip.Model.getNLPIterations -pyscipopt.scip.Model.getNLPRows -pyscipopt.scip.Model.getNLPs -pyscipopt.scip.Model.getNLeaves -pyscipopt.scip.Model.getNLimSolsFound -pyscipopt.scip.Model.getNNlRows -pyscipopt.scip.Model.getNNodeLPIterations -pyscipopt.scip.Model.getNNodes -pyscipopt.scip.Model.getNReaders -pyscipopt.scip.Model.getNSepaRounds -pyscipopt.scip.Model.getNSiblings -pyscipopt.scip.Model.getNSols -pyscipopt.scip.Model.getNSolsFound -pyscipopt.scip.Model.getNStrongbranchLPIterations -pyscipopt.scip.Model.getNTotalNodes -pyscipopt.scip.Model.getNVars -pyscipopt.scip.Model.getNVarsAnd -pyscipopt.scip.Model.getNlRowActivityBounds -pyscipopt.scip.Model.getNlRowSolActivity -pyscipopt.scip.Model.getNlRowSolFeasibility -pyscipopt.scip.Model.getNlRows -pyscipopt.scip.Model.getObjVal -pyscipopt.scip.Model.getObjective -pyscipopt.scip.Model.getObjectiveSense -pyscipopt.scip.Model.getObjlimit -pyscipopt.scip.Model.getObjoffset -pyscipopt.scip.Model.getOpenNodes -pyscipopt.scip.Model.getParam -pyscipopt.scip.Model.getParams -pyscipopt.scip.Model.getPlungeDepth -pyscipopt.scip.Model.getPresolvingTime -pyscipopt.scip.Model.getPrimalRay -pyscipopt.scip.Model.getPrimalRayVal -pyscipopt.scip.Model.getPrimalbound -pyscipopt.scip.Model.getPrioChild -pyscipopt.scip.Model.getPrioSibling -pyscipopt.scip.Model.getProbName -pyscipopt.scip.Model.getProbingDepth -pyscipopt.scip.Model.getPseudoBranchCands -pyscipopt.scip.Model.getReadingTime -pyscipopt.scip.Model.getResultantAnd -pyscipopt.scip.Model.getRhs -pyscipopt.scip.Model.getRowActivity -pyscipopt.scip.Model.getRowDualSol -pyscipopt.scip.Model.getRowLPActivity -pyscipopt.scip.Model.getRowLinear -pyscipopt.scip.Model.getRowNumIntCols -pyscipopt.scip.Model.getRowObjParallelism -pyscipopt.scip.Model.getRowParallelism -pyscipopt.scip.Model.getSiblings -pyscipopt.scip.Model.getSlack -pyscipopt.scip.Model.getSlackVarIndicator -pyscipopt.scip.Model.getSolObjVal -pyscipopt.scip.Model.getSolTime -pyscipopt.scip.Model.getSolVal -pyscipopt.scip.Model.getSols -pyscipopt.scip.Model.getSolvingTime -pyscipopt.scip.Model.getStage -pyscipopt.scip.Model.getStageName -pyscipopt.scip.Model.getStatus -pyscipopt.scip.Model.getTechVersion -pyscipopt.scip.Model.getTermsQuadratic -pyscipopt.scip.Model.getTotalTime -pyscipopt.scip.Model.getTransformedCons -pyscipopt.scip.Model.getTransformedVar -pyscipopt.scip.Model.getTreesizeEstimation -pyscipopt.scip.Model.getVal -pyscipopt.scip.Model.getValsLinear -pyscipopt.scip.Model.getVarDict -pyscipopt.scip.Model.getVarLbDive -pyscipopt.scip.Model.getVarPseudocost -pyscipopt.scip.Model.getVarPseudocostScore -pyscipopt.scip.Model.getVarRedcost -pyscipopt.scip.Model.getVarStrongbranch -pyscipopt.scip.Model.getVarStrongbranchLast -pyscipopt.scip.Model.getVarStrongbranchNode -pyscipopt.scip.Model.getVarUbDive -pyscipopt.scip.Model.getVars -pyscipopt.scip.Model.getVarsAnd -pyscipopt.scip.Model.getWeightsKnapsack -pyscipopt.scip.Model.hasPrimalRay -pyscipopt.scip.Model.hideOutput -pyscipopt.scip.Model.inProbing -pyscipopt.scip.Model.inRepropagation -pyscipopt.scip.Model.includeBenders -pyscipopt.scip.Model.includeBendersDefaultCuts -pyscipopt.scip.Model.includeBenderscut -pyscipopt.scip.Model.includeBranchrule -pyscipopt.scip.Model.includeConshdlr -pyscipopt.scip.Model.includeCutsel -pyscipopt.scip.Model.includeDefaultPlugins -pyscipopt.scip.Model.includeEventhdlr -pyscipopt.scip.Model.includeHeur -pyscipopt.scip.Model.includeIISfinder -pyscipopt.scip.Model.includeNodesel -pyscipopt.scip.Model.includePresol -pyscipopt.scip.Model.includePricer -pyscipopt.scip.Model.includeProp -pyscipopt.scip.Model.includeReader -pyscipopt.scip.Model.includeRelax -pyscipopt.scip.Model.includeSepa -pyscipopt.scip.Model.infinity -pyscipopt.scip.Model.initBendersDefault -pyscipopt.scip.Model.interruptSolve -pyscipopt.scip.Model.isAndConsSorted -pyscipopt.scip.Model.isCutEfficacious -pyscipopt.scip.Model.isEQ -pyscipopt.scip.Model.isExact -pyscipopt.scip.Model.isFeasEQ -pyscipopt.scip.Model.isFeasGE -pyscipopt.scip.Model.isFeasGT -pyscipopt.scip.Model.isFeasIntegral -pyscipopt.scip.Model.isFeasLE -pyscipopt.scip.Model.isFeasLT -pyscipopt.scip.Model.isFeasNegative -pyscipopt.scip.Model.isFeasPositive -pyscipopt.scip.Model.isFeasZero -pyscipopt.scip.Model.isGE -pyscipopt.scip.Model.isGT -pyscipopt.scip.Model.isHugeValue -pyscipopt.scip.Model.isInfinity -pyscipopt.scip.Model.isLE -pyscipopt.scip.Model.isLPSolBasic -pyscipopt.scip.Model.isLT -pyscipopt.scip.Model.isNLPConstructed -pyscipopt.scip.Model.isNegative -pyscipopt.scip.Model.isObjChangedProbing -pyscipopt.scip.Model.isPositive -pyscipopt.scip.Model.isZero -pyscipopt.scip.Model.lpiGetIterations -pyscipopt.scip.Model.markDoNotAggrVar -pyscipopt.scip.Model.markDoNotMultaggrVar -pyscipopt.scip.Model.newProbingNode -pyscipopt.scip.Model.optimize -pyscipopt.scip.Model.optimizeNogil -pyscipopt.scip.Model.presolve -pyscipopt.scip.Model.printBestSol -pyscipopt.scip.Model.printCons -pyscipopt.scip.Model.printExternalCodeVersions -pyscipopt.scip.Model.printNlRow -pyscipopt.scip.Model.printProblem -pyscipopt.scip.Model.printRow -pyscipopt.scip.Model.printSol -pyscipopt.scip.Model.printStatistics -pyscipopt.scip.Model.printStatisticsJson -pyscipopt.scip.Model.printVersion -pyscipopt.scip.Model.propagateProbing -pyscipopt.scip.Model.readParams -pyscipopt.scip.Model.readProblem -pyscipopt.scip.Model.readSol -pyscipopt.scip.Model.readSolFile -pyscipopt.scip.Model.redirectOutput -pyscipopt.scip.Model.relax -pyscipopt.scip.Model.releaseRow -pyscipopt.scip.Model.repropagateNode -pyscipopt.scip.Model.resetParam -pyscipopt.scip.Model.resetParams -pyscipopt.scip.Model.restartSolve -pyscipopt.scip.Model.separateSol -pyscipopt.scip.Model.setBendersSubproblemIsConvex -pyscipopt.scip.Model.setBoolParam -pyscipopt.scip.Model.setCharParam -pyscipopt.scip.Model.setCheck -pyscipopt.scip.Model.setEmphasis -pyscipopt.scip.Model.setEnforced -pyscipopt.scip.Model.setHeurTiming -pyscipopt.scip.Model.setHeuristics -pyscipopt.scip.Model.setInitial -pyscipopt.scip.Model.setIntParam -pyscipopt.scip.Model.setLogfile -pyscipopt.scip.Model.setLongintParam -pyscipopt.scip.Model.setMaximize -pyscipopt.scip.Model.setMinimize -pyscipopt.scip.Model.setModifiable -pyscipopt.scip.Model.setObjIntegral -pyscipopt.scip.Model.setObjective -pyscipopt.scip.Model.setObjlimit -pyscipopt.scip.Model.setParam -pyscipopt.scip.Model.setParams -pyscipopt.scip.Model.setParamsCountsols -pyscipopt.scip.Model.setPresolve -pyscipopt.scip.Model.setProbName -pyscipopt.scip.Model.setRealParam -pyscipopt.scip.Model.setRelaxSolVal -pyscipopt.scip.Model.setRemovable -pyscipopt.scip.Model.setSeparating -pyscipopt.scip.Model.setSolVal -pyscipopt.scip.Model.setStringParam -pyscipopt.scip.Model.setupBendersSubproblem -pyscipopt.scip.Model.solveBendersSubproblem -pyscipopt.scip.Model.solveConcurrent -pyscipopt.scip.Model.solveDiveLP -pyscipopt.scip.Model.solveProbingLP -pyscipopt.scip.Model.sortAndCons -pyscipopt.scip.Model.startDive -pyscipopt.scip.Model.startProbing -pyscipopt.scip.Model.startStrongbranch -pyscipopt.scip.Model.tightenVarLb -pyscipopt.scip.Model.tightenVarLbGlobal -pyscipopt.scip.Model.tightenVarUb -pyscipopt.scip.Model.tightenVarUbGlobal -pyscipopt.scip.Model.to_ptr -pyscipopt.scip.Model.translateSubSol -pyscipopt.scip.Model.trySol -pyscipopt.scip.Model.updateBendersLowerbounds -pyscipopt.scip.Model.updateNodeLowerbound -pyscipopt.scip.Model.updateVarPseudocost -pyscipopt.scip.Model.version -pyscipopt.scip.Model.writeBestSol -pyscipopt.scip.Model.writeBestTransSol -pyscipopt.scip.Model.writeLP -pyscipopt.scip.Model.writeMIP -pyscipopt.scip.Model.writeName -pyscipopt.scip.Model.writeParams -pyscipopt.scip.Model.writeProblem -pyscipopt.scip.Model.writeSol -pyscipopt.scip.Model.writeStatistics -pyscipopt.scip.Model.writeStatisticsJson -pyscipopt.scip.Model.writeTransSol -pyscipopt.scip.NLRow -pyscipopt.scip.NLRow.__init__ -pyscipopt.scip.NLRow.getConstant -pyscipopt.scip.NLRow.getDualsol -pyscipopt.scip.NLRow.getLhs -pyscipopt.scip.NLRow.getLinearTerms -pyscipopt.scip.NLRow.getRhs -pyscipopt.scip.Node -pyscipopt.scip.Node.__init__ -pyscipopt.scip.Node.getAddedConss -pyscipopt.scip.Node.getDepth -pyscipopt.scip.Node.getDomchg -pyscipopt.scip.Node.getEstimate -pyscipopt.scip.Node.getLowerbound -pyscipopt.scip.Node.getNAddedConss -pyscipopt.scip.Node.getNDomchg -pyscipopt.scip.Node.getNParentBranchings -pyscipopt.scip.Node.getNumber -pyscipopt.scip.Node.getParent -pyscipopt.scip.Node.getParentBranchings -pyscipopt.scip.Node.getType -pyscipopt.scip.Node.isActive -pyscipopt.scip.Node.isPropagatedAgain -pyscipopt.scip.Nodesel -pyscipopt.scip.Nodesel.__init__ -pyscipopt.scip.Nodesel.nodecomp -pyscipopt.scip.Nodesel.nodeexit -pyscipopt.scip.Nodesel.nodeexitsol -pyscipopt.scip.Nodesel.nodefree -pyscipopt.scip.Nodesel.nodeinit -pyscipopt.scip.Nodesel.nodeinitsol -pyscipopt.scip.Nodesel.nodeselect -pyscipopt.scip.PY_SCIP_BENDERSENFOTYPE.__init__ -pyscipopt.scip.PY_SCIP_BRANCHDIR.__init__ -pyscipopt.scip.PY_SCIP_EVENTTYPE.__init__ -pyscipopt.scip.PY_SCIP_HEURTIMING.__init__ -pyscipopt.scip.PY_SCIP_IMPLINTTYPE.__init__ -pyscipopt.scip.PY_SCIP_LOCKTYPE.__init__ -pyscipopt.scip.PY_SCIP_LPPARAM.__init__ -pyscipopt.scip.PY_SCIP_LPSOLSTAT.__init__ -pyscipopt.scip.PY_SCIP_NODETYPE.__init__ -pyscipopt.scip.PY_SCIP_PARAMEMPHASIS.__init__ -pyscipopt.scip.PY_SCIP_PARAMSETTING.__init__ -pyscipopt.scip.PY_SCIP_PRESOLTIMING.__init__ -pyscipopt.scip.PY_SCIP_PROPTIMING.__init__ -pyscipopt.scip.PY_SCIP_RESULT.__init__ -pyscipopt.scip.PY_SCIP_ROWORIGINTYPE.__init__ -pyscipopt.scip.PY_SCIP_SOLORIGIN.__init__ -pyscipopt.scip.PY_SCIP_STAGE.__init__ -pyscipopt.scip.PY_SCIP_STATUS.__init__ -pyscipopt.scip.PowExpr -pyscipopt.scip.Presol -pyscipopt.scip.Presol.__init__ -pyscipopt.scip.Presol.presolexec -pyscipopt.scip.Presol.presolexit -pyscipopt.scip.Presol.presolexitpre -pyscipopt.scip.Presol.presolfree -pyscipopt.scip.Presol.presolinit -pyscipopt.scip.Presol.presolinitpre -pyscipopt.scip.Pricer -pyscipopt.scip.Pricer.__init__ -pyscipopt.scip.Pricer.pricerexit -pyscipopt.scip.Pricer.pricerexitsol -pyscipopt.scip.Pricer.pricerfarkas -pyscipopt.scip.Pricer.pricerfree -pyscipopt.scip.Pricer.pricerinit -pyscipopt.scip.Pricer.pricerinitsol -pyscipopt.scip.Pricer.pricerredcost -pyscipopt.scip.ProdExpr -pyscipopt.scip.Prop -pyscipopt.scip.Prop.__init__ -pyscipopt.scip.Prop.propexec -pyscipopt.scip.Prop.propexit -pyscipopt.scip.Prop.propexitpre -pyscipopt.scip.Prop.propexitsol -pyscipopt.scip.Prop.propfree -pyscipopt.scip.Prop.propinit -pyscipopt.scip.Prop.propinitpre -pyscipopt.scip.Prop.propinitsol -pyscipopt.scip.Prop.proppresol -pyscipopt.scip.Prop.propresprop -pyscipopt.scip.Reader -pyscipopt.scip.Reader.__init__ -pyscipopt.scip.Reader.readerfree -pyscipopt.scip.Reader.readerread -pyscipopt.scip.Reader.readerwrite -pyscipopt.scip.Relax -pyscipopt.scip.Relax.__init__ -pyscipopt.scip.Relax.relaxexec -pyscipopt.scip.Relax.relaxexit -pyscipopt.scip.Relax.relaxexitsol -pyscipopt.scip.Relax.relaxfree -pyscipopt.scip.Relax.relaxinit -pyscipopt.scip.Relax.relaxinitsol -pyscipopt.scip.Row -pyscipopt.scip.Row.__init__ -pyscipopt.scip.Row.getAge -pyscipopt.scip.Row.getBasisStatus -pyscipopt.scip.Row.getCols -pyscipopt.scip.Row.getConsOriginConshdlrtype -pyscipopt.scip.Row.getConstant -pyscipopt.scip.Row.getDualfarkas -pyscipopt.scip.Row.getDualsol -pyscipopt.scip.Row.getLPPos -pyscipopt.scip.Row.getLhs -pyscipopt.scip.Row.getNLPNonz -pyscipopt.scip.Row.getNNonz -pyscipopt.scip.Row.getNorm -pyscipopt.scip.Row.getOrigintype -pyscipopt.scip.Row.getRhs -pyscipopt.scip.Row.getVals -pyscipopt.scip.Row.isInGlobalCutpool -pyscipopt.scip.Row.isIntegral -pyscipopt.scip.Row.isLocal -pyscipopt.scip.Row.isModifiable -pyscipopt.scip.Row.isRemovable -pyscipopt.scip.RowExact -pyscipopt.scip.RowExact.__init__ -pyscipopt.scip.Sepa -pyscipopt.scip.Sepa.__init__ -pyscipopt.scip.Sepa.sepaexeclp -pyscipopt.scip.Sepa.sepaexecsol -pyscipopt.scip.Sepa.sepaexit -pyscipopt.scip.Sepa.sepaexitsol -pyscipopt.scip.Sepa.sepafree -pyscipopt.scip.Sepa.sepainit -pyscipopt.scip.Sepa.sepainitsol -pyscipopt.scip.Solution -pyscipopt.scip.Solution._checkStage -pyscipopt.scip.Solution._evaluate -pyscipopt.scip.Solution.getOrigin -pyscipopt.scip.Solution.retransform -pyscipopt.scip.Solution.translate -pyscipopt.scip.Statistics.__init__ -pyscipopt.scip.Statistics.__match_args__ -pyscipopt.scip.SumExpr -pyscipopt.scip.Term.__init__ -pyscipopt.scip.VarExpr -pyscipopt.scip.Variable -pyscipopt.scip.Variable.getAvgSol -pyscipopt.scip.Variable.getCol -pyscipopt.scip.Variable.getImplType -pyscipopt.scip.Variable.getIndex -pyscipopt.scip.Variable.getLPSol -pyscipopt.scip.Variable.getLbGlobal -pyscipopt.scip.Variable.getLbLocal -pyscipopt.scip.Variable.getLbOriginal -pyscipopt.scip.Variable.getNBranchings -pyscipopt.scip.Variable.getNBranchingsCurrentRun -pyscipopt.scip.Variable.getNLocksDown -pyscipopt.scip.Variable.getNLocksDownType -pyscipopt.scip.Variable.getNLocksUp -pyscipopt.scip.Variable.getNLocksUpType -pyscipopt.scip.Variable.getObj -pyscipopt.scip.Variable.getStatus -pyscipopt.scip.Variable.getUbGlobal -pyscipopt.scip.Variable.getUbLocal -pyscipopt.scip.Variable.getUbOriginal -pyscipopt.scip.Variable.isActive -pyscipopt.scip.Variable.isBinary -pyscipopt.scip.Variable.isDeletable -pyscipopt.scip.Variable.isImpliedIntegral -pyscipopt.scip.Variable.isInLP -pyscipopt.scip.Variable.isIntegral -pyscipopt.scip.Variable.isNonImpliedIntegral -pyscipopt.scip.Variable.isOriginal -pyscipopt.scip.Variable.isRelaxationOnly -pyscipopt.scip.Variable.markRelaxationOnly -pyscipopt.scip.Variable.ptr -pyscipopt.scip.Variable.varMayRound -pyscipopt.scip.Variable.vtype -pyscipopt.scip._VarArray -pyscipopt.scip._VarArray.__init__ From 5e6ece362a81461caab59e3720299e7b2261ca57 Mon Sep 17 00:00:00 2001 From: Jonathan Berthias Date: Mon, 29 Dec 2025 15:35:50 +0100 Subject: [PATCH 09/15] Check import order in stubs --- .github/workflows/stubs.yml | 2 +- src/pyscipopt/scip.pyi | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/stubs.yml b/.github/workflows/stubs.yml index 715e923c3..9fd0c3768 100644 --- a/.github/workflows/stubs.yml +++ b/.github/workflows/stubs.yml @@ -65,7 +65,7 @@ jobs: args: "--version" - name: Lint type stubs - run: ruff check ${{ env.FILES }} --extend-select PYI + run: ruff check ${{ env.FILES }} --extend-select I,PYI - name: Format type stubs run: ruff format ${{ env.FILES }} diff --git a/src/pyscipopt/scip.pyi b/src/pyscipopt/scip.pyi index d4226c452..ccdd419e7 100644 --- a/src/pyscipopt/scip.pyi +++ b/src/pyscipopt/scip.pyi @@ -1,9 +1,9 @@ from dataclasses import dataclass from typing import ClassVar -from typing_extensions import disjoint_base import numpy from _typeshed import Incomplete +from typing_extensions import disjoint_base CONST: Term EventNames: dict From 077e632010c13f365f6e748bff5418188df9cc3f Mon Sep 17 00:00:00 2001 From: Jonathan Berthias Date: Mon, 29 Dec 2025 15:36:45 +0100 Subject: [PATCH 10/15] Format stubs file --- src/pyscipopt/scip.pyi | 1033 ++++++++++++++++++++++++++++++++++------ 1 file changed, 888 insertions(+), 145 deletions(-) diff --git a/src/pyscipopt/scip.pyi b/src/pyscipopt/scip.pyi index ccdd419e7..ef61239f8 100644 --- a/src/pyscipopt/scip.pyi +++ b/src/pyscipopt/scip.pyi @@ -44,14 +44,30 @@ class Benders: def bendersexitsol(self) -> Incomplete: ... def bendersfree(self) -> Incomplete: ... def bendersfreesub(self, probnumber: Incomplete) -> Incomplete: ... - def bendersgetvar(self, variable: Incomplete, probnumber: Incomplete) -> Incomplete: ... + def bendersgetvar( + self, variable: Incomplete, probnumber: Incomplete + ) -> Incomplete: ... def bendersinit(self) -> Incomplete: ... def bendersinitpre(self) -> Incomplete: ... def bendersinitsol(self) -> Incomplete: ... - def benderspostsolve(self, solution: Incomplete, enfotype: Incomplete, mergecandidates: Incomplete, npriomergecands: Incomplete, checkint: Incomplete, infeasible: Incomplete) -> Incomplete: ... - def benderspresubsolve(self, solution: Incomplete, enfotype: Incomplete, checkint: Incomplete) -> Incomplete: ... - def benderssolvesub(self, solution: Incomplete, probnumber: Incomplete) -> Incomplete: ... - def benderssolvesubconvex(self, solution: Incomplete, probnumber: Incomplete, onlyconvex: Incomplete) -> Incomplete: ... + def benderspostsolve( + self, + solution: Incomplete, + enfotype: Incomplete, + mergecandidates: Incomplete, + npriomergecands: Incomplete, + checkint: Incomplete, + infeasible: Incomplete, + ) -> Incomplete: ... + def benderspresubsolve( + self, solution: Incomplete, enfotype: Incomplete, checkint: Incomplete + ) -> Incomplete: ... + def benderssolvesub( + self, solution: Incomplete, probnumber: Incomplete + ) -> Incomplete: ... + def benderssolvesubconvex( + self, solution: Incomplete, probnumber: Incomplete, onlyconvex: Incomplete + ) -> Incomplete: ... @disjoint_base class Benderscut: @@ -59,7 +75,9 @@ class Benderscut: model: Incomplete name: Incomplete def __init__(self) -> None: ... - def benderscutexec(self, solution: Incomplete, probnumber: Incomplete, enfotype: Incomplete) -> Incomplete: ... + def benderscutexec( + self, solution: Incomplete, probnumber: Incomplete, enfotype: Incomplete + ) -> Incomplete: ... def benderscutexit(self) -> Incomplete: ... def benderscutexitsol(self) -> Incomplete: ... def benderscutfree(self) -> Incomplete: ... @@ -120,19 +138,46 @@ class Conshdlr: name: Incomplete def __init__(self) -> None: ... def consactive(self, constraint: Incomplete) -> Incomplete: ... - def conscheck(self, constraints: Incomplete, solution: Incomplete, checkintegrality: Incomplete, checklprows: Incomplete, printreason: Incomplete, completely: Incomplete) -> Incomplete: ... + def conscheck( + self, + constraints: Incomplete, + solution: Incomplete, + checkintegrality: Incomplete, + checklprows: Incomplete, + printreason: Incomplete, + completely: Incomplete, + ) -> Incomplete: ... def conscopy(self) -> Incomplete: ... def consdeactive(self, constraint: Incomplete) -> Incomplete: ... def consdelete(self, constraint: Incomplete) -> Incomplete: ... def consdelvars(self, constraints: Incomplete) -> Incomplete: ... def consdisable(self, constraint: Incomplete) -> Incomplete: ... def consenable(self, constraint: Incomplete) -> Incomplete: ... - def consenfolp(self, constraints: Incomplete, nusefulconss: Incomplete, solinfeasible: Incomplete) -> Incomplete: ... - def consenfops(self, constraints: Incomplete, nusefulconss: Incomplete, solinfeasible: Incomplete, objinfeasible: Incomplete) -> Incomplete: ... - def consenforelax(self, solution: Incomplete, constraints: Incomplete, nusefulconss: Incomplete, solinfeasible: Incomplete) -> Incomplete: ... + def consenfolp( + self, + constraints: Incomplete, + nusefulconss: Incomplete, + solinfeasible: Incomplete, + ) -> Incomplete: ... + def consenfops( + self, + constraints: Incomplete, + nusefulconss: Incomplete, + solinfeasible: Incomplete, + objinfeasible: Incomplete, + ) -> Incomplete: ... + def consenforelax( + self, + solution: Incomplete, + constraints: Incomplete, + nusefulconss: Incomplete, + solinfeasible: Incomplete, + ) -> Incomplete: ... def consexit(self, constraints: Incomplete) -> Incomplete: ... def consexitpre(self, constraints: Incomplete) -> Incomplete: ... - def consexitsol(self, constraints: Incomplete, restart: Incomplete) -> Incomplete: ... + def consexitsol( + self, constraints: Incomplete, restart: Incomplete + ) -> Incomplete: ... def consfree(self) -> Incomplete: ... def consgetdivebdchgs(self) -> Incomplete: ... def consgetnvars(self, constraint: Incomplete) -> Incomplete: ... @@ -143,14 +188,46 @@ class Conshdlr: def consinitlp(self, constraints: Incomplete) -> Incomplete: ... def consinitpre(self, constraints: Incomplete) -> Incomplete: ... def consinitsol(self, constraints: Incomplete) -> Incomplete: ... - def conslock(self, constraint: Incomplete, locktype: Incomplete, nlockspos: Incomplete, nlocksneg: Incomplete) -> Incomplete: ... + def conslock( + self, + constraint: Incomplete, + locktype: Incomplete, + nlockspos: Incomplete, + nlocksneg: Incomplete, + ) -> Incomplete: ... def consparse(self) -> Incomplete: ... - def conspresol(self, constraints: Incomplete, nrounds: Incomplete, presoltiming: Incomplete, nnewfixedvars: Incomplete, nnewaggrvars: Incomplete, nnewchgvartypes: Incomplete, nnewchgbds: Incomplete, nnewholes: Incomplete, nnewdelconss: Incomplete, nnewaddconss: Incomplete, nnewupgdconss: Incomplete, nnewchgcoefs: Incomplete, nnewchgsides: Incomplete, result_dict: Incomplete) -> Incomplete: ... + def conspresol( + self, + constraints: Incomplete, + nrounds: Incomplete, + presoltiming: Incomplete, + nnewfixedvars: Incomplete, + nnewaggrvars: Incomplete, + nnewchgvartypes: Incomplete, + nnewchgbds: Incomplete, + nnewholes: Incomplete, + nnewdelconss: Incomplete, + nnewaddconss: Incomplete, + nnewupgdconss: Incomplete, + nnewchgcoefs: Incomplete, + nnewchgsides: Incomplete, + result_dict: Incomplete, + ) -> Incomplete: ... def consprint(self, constraint: Incomplete) -> Incomplete: ... - def consprop(self, constraints: Incomplete, nusefulconss: Incomplete, nmarkedconss: Incomplete, proptiming: Incomplete) -> Incomplete: ... + def consprop( + self, + constraints: Incomplete, + nusefulconss: Incomplete, + nmarkedconss: Incomplete, + proptiming: Incomplete, + ) -> Incomplete: ... def consresprop(self) -> Incomplete: ... - def conssepalp(self, constraints: Incomplete, nusefulconss: Incomplete) -> Incomplete: ... - def conssepasol(self, constraints: Incomplete, nusefulconss: Incomplete, solution: Incomplete) -> Incomplete: ... + def conssepalp( + self, constraints: Incomplete, nusefulconss: Incomplete + ) -> Incomplete: ... + def conssepasol( + self, constraints: Incomplete, nusefulconss: Incomplete, solution: Incomplete + ) -> Incomplete: ... def constrans(self, sourceconstraint: Incomplete) -> Incomplete: ... @disjoint_base @@ -197,7 +274,13 @@ class Cutsel: def cutselfree(self) -> Incomplete: ... def cutselinit(self) -> Incomplete: ... def cutselinitsol(self) -> Incomplete: ... - def cutselselect(self, cuts: Incomplete, forcedcuts: Incomplete, root: Incomplete, maxnselectedcuts: Incomplete) -> Incomplete: ... + def cutselselect( + self, + cuts: Incomplete, + forcedcuts: Incomplete, + root: Incomplete, + maxnselectedcuts: Incomplete, + ) -> Incomplete: ... @disjoint_base class DomainChanges: @@ -313,7 +396,9 @@ class Heur: model: Incomplete name: Incomplete def __init__(self) -> None: ... - def heurexec(self, heurtiming: Incomplete, nodeinfeasible: Incomplete) -> Incomplete: ... + def heurexec( + self, heurtiming: Incomplete, nodeinfeasible: Incomplete + ) -> Incomplete: ... def heurexit(self) -> Incomplete: ... def heurexitsol(self) -> Incomplete: ... def heurfree(self) -> Incomplete: ... @@ -343,20 +428,44 @@ class IISfinder: class LP: name: Incomplete def __init__(self, *args, **kwargs) -> None: ... - def addCol(self, entries: Incomplete, obj: Incomplete = ..., lb: Incomplete = ..., ub: Incomplete = ...) -> Incomplete: ... - def addCols(self, entrieslist: Incomplete, objs: Incomplete = ..., lbs: Incomplete = ..., ubs: Incomplete = ...) -> Incomplete: ... - def addRow(self, entries: Incomplete, lhs: Incomplete = ..., rhs: Incomplete = ...) -> Incomplete: ... - def addRows(self, entrieslist: Incomplete, lhss: Incomplete = ..., rhss: Incomplete = ...) -> Incomplete: ... - def chgBound(self, col: Incomplete, lb: Incomplete, ub: Incomplete) -> Incomplete: ... - def chgCoef(self, row: Incomplete, col: Incomplete, newval: Incomplete) -> Incomplete: ... + def addCol( + self, + entries: Incomplete, + obj: Incomplete = ..., + lb: Incomplete = ..., + ub: Incomplete = ..., + ) -> Incomplete: ... + def addCols( + self, + entrieslist: Incomplete, + objs: Incomplete = ..., + lbs: Incomplete = ..., + ubs: Incomplete = ..., + ) -> Incomplete: ... + def addRow( + self, entries: Incomplete, lhs: Incomplete = ..., rhs: Incomplete = ... + ) -> Incomplete: ... + def addRows( + self, entrieslist: Incomplete, lhss: Incomplete = ..., rhss: Incomplete = ... + ) -> Incomplete: ... + def chgBound( + self, col: Incomplete, lb: Incomplete, ub: Incomplete + ) -> Incomplete: ... + def chgCoef( + self, row: Incomplete, col: Incomplete, newval: Incomplete + ) -> Incomplete: ... def chgObj(self, col: Incomplete, obj: Incomplete) -> Incomplete: ... - def chgSide(self, row: Incomplete, lhs: Incomplete, rhs: Incomplete) -> Incomplete: ... + def chgSide( + self, row: Incomplete, lhs: Incomplete, rhs: Incomplete + ) -> Incomplete: ... def clear(self) -> Incomplete: ... def delCols(self, firstcol: Incomplete, lastcol: Incomplete) -> Incomplete: ... def delRows(self, firstrow: Incomplete, lastrow: Incomplete) -> Incomplete: ... def getActivity(self) -> Incomplete: ... def getBasisInds(self) -> Incomplete: ... - def getBounds(self, firstcol: Incomplete = ..., lastcol: Incomplete = ...) -> Incomplete: ... + def getBounds( + self, firstcol: Incomplete = ..., lastcol: Incomplete = ... + ) -> Incomplete: ... def getDual(self) -> Incomplete: ... def getDualRay(self) -> Incomplete: ... def getIntParam(self, param: Incomplete) -> Incomplete: ... @@ -366,7 +475,9 @@ class LP: def getPrimalRay(self) -> Incomplete: ... def getRealParam(self, param: Incomplete) -> Incomplete: ... def getRedcost(self) -> Incomplete: ... - def getSides(self, firstrow: Incomplete = ..., lastrow: Incomplete = ...) -> Incomplete: ... + def getSides( + self, firstrow: Incomplete = ..., lastrow: Incomplete = ... + ) -> Incomplete: ... def infinity(self) -> Incomplete: ... def isDualFeasible(self) -> Incomplete: ... def isInfinity(self, val: Incomplete) -> Incomplete: ... @@ -441,78 +552,365 @@ class Model: _freescip: Incomplete data: Incomplete def __init__(self, *args, **kwargs) -> None: ... - def _createConsGenNonlinear(self, cons: Incomplete, **kwargs: Incomplete) -> Incomplete: ... - def _createConsLinear(self, lincons: Incomplete, **kwargs: Incomplete) -> Incomplete: ... - def _createConsNonlinear(self, cons: Incomplete, **kwargs: Incomplete) -> Incomplete: ... - def _createConsQuadratic(self, quadcons: Incomplete, **kwargs: Incomplete) -> Incomplete: ... + def _createConsGenNonlinear( + self, cons: Incomplete, **kwargs: Incomplete + ) -> Incomplete: ... + def _createConsLinear( + self, lincons: Incomplete, **kwargs: Incomplete + ) -> Incomplete: ... + def _createConsNonlinear( + self, cons: Incomplete, **kwargs: Incomplete + ) -> Incomplete: ... + def _createConsQuadratic( + self, quadcons: Incomplete, **kwargs: Incomplete + ) -> Incomplete: ... def _getStageNames(self) -> Incomplete: ... - def activateBenders(self, benders: Incomplete, nsubproblems: Incomplete) -> Incomplete: ... - def addBendersSubproblem(self, benders: Incomplete, subproblem: Incomplete) -> Incomplete: ... - def addCoefKnapsack(self, cons: Incomplete, var: Incomplete, weight: Incomplete) -> Incomplete: ... - def addCoefLinear(self, cons: Incomplete, var: Incomplete, value: Incomplete) -> Incomplete: ... - def addCons(self, cons: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... - def addConsAnd(self, vars: Incomplete, resvar: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... - def addConsCardinality(self, consvars: Incomplete, cardval: Incomplete, indvars: Incomplete = ..., weights: Incomplete = ..., name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... - def addConsCoeff(self, cons: Incomplete, var: Incomplete, coeff: Incomplete) -> Incomplete: ... - def addConsDisjunction(self, conss: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., relaxcons: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ...) -> Incomplete: ... - def addConsElemDisjunction(self, disj_cons: Incomplete, cons: Incomplete) -> Incomplete: ... - def addConsIndicator(self, cons: Incomplete, binvar: Incomplete = ..., activeone: Incomplete = ..., name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... - def addConsKnapsack(self, vars: Incomplete, weights: Incomplete, capacity: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., modifiable: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... - def addConsLocal(self, cons: Incomplete, validnode: Incomplete = ...) -> Incomplete: ... - def addConsNode(self, node: Incomplete, cons: Incomplete, validnode: Incomplete = ...) -> Incomplete: ... - def addConsOr(self, vars: Incomplete, resvar: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... - def addConsSOS1(self, vars: Incomplete, weights: Incomplete = ..., name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... - def addConsSOS2(self, vars: Incomplete, weights: Incomplete = ..., name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... - def addConsXor(self, vars: Incomplete, rhsvar: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... - def addConss(self, conss: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... + def activateBenders( + self, benders: Incomplete, nsubproblems: Incomplete + ) -> Incomplete: ... + def addBendersSubproblem( + self, benders: Incomplete, subproblem: Incomplete + ) -> Incomplete: ... + def addCoefKnapsack( + self, cons: Incomplete, var: Incomplete, weight: Incomplete + ) -> Incomplete: ... + def addCoefLinear( + self, cons: Incomplete, var: Incomplete, value: Incomplete + ) -> Incomplete: ... + def addCons( + self, + cons: Incomplete, + name: Incomplete = ..., + initial: Incomplete = ..., + separate: Incomplete = ..., + enforce: Incomplete = ..., + check: Incomplete = ..., + propagate: Incomplete = ..., + local: Incomplete = ..., + modifiable: Incomplete = ..., + dynamic: Incomplete = ..., + removable: Incomplete = ..., + stickingatnode: Incomplete = ..., + ) -> Incomplete: ... + def addConsAnd( + self, + vars: Incomplete, + resvar: Incomplete, + name: Incomplete = ..., + initial: Incomplete = ..., + separate: Incomplete = ..., + enforce: Incomplete = ..., + check: Incomplete = ..., + propagate: Incomplete = ..., + local: Incomplete = ..., + modifiable: Incomplete = ..., + dynamic: Incomplete = ..., + removable: Incomplete = ..., + stickingatnode: Incomplete = ..., + ) -> Incomplete: ... + def addConsCardinality( + self, + consvars: Incomplete, + cardval: Incomplete, + indvars: Incomplete = ..., + weights: Incomplete = ..., + name: Incomplete = ..., + initial: Incomplete = ..., + separate: Incomplete = ..., + enforce: Incomplete = ..., + check: Incomplete = ..., + propagate: Incomplete = ..., + local: Incomplete = ..., + dynamic: Incomplete = ..., + removable: Incomplete = ..., + stickingatnode: Incomplete = ..., + ) -> Incomplete: ... + def addConsCoeff( + self, cons: Incomplete, var: Incomplete, coeff: Incomplete + ) -> Incomplete: ... + def addConsDisjunction( + self, + conss: Incomplete, + name: Incomplete = ..., + initial: Incomplete = ..., + relaxcons: Incomplete = ..., + enforce: Incomplete = ..., + check: Incomplete = ..., + local: Incomplete = ..., + modifiable: Incomplete = ..., + dynamic: Incomplete = ..., + ) -> Incomplete: ... + def addConsElemDisjunction( + self, disj_cons: Incomplete, cons: Incomplete + ) -> Incomplete: ... + def addConsIndicator( + self, + cons: Incomplete, + binvar: Incomplete = ..., + activeone: Incomplete = ..., + name: Incomplete = ..., + initial: Incomplete = ..., + separate: Incomplete = ..., + enforce: Incomplete = ..., + check: Incomplete = ..., + propagate: Incomplete = ..., + local: Incomplete = ..., + dynamic: Incomplete = ..., + removable: Incomplete = ..., + stickingatnode: Incomplete = ..., + ) -> Incomplete: ... + def addConsKnapsack( + self, + vars: Incomplete, + weights: Incomplete, + capacity: Incomplete, + name: Incomplete = ..., + initial: Incomplete = ..., + separate: Incomplete = ..., + enforce: Incomplete = ..., + check: Incomplete = ..., + modifiable: Incomplete = ..., + propagate: Incomplete = ..., + local: Incomplete = ..., + dynamic: Incomplete = ..., + removable: Incomplete = ..., + stickingatnode: Incomplete = ..., + ) -> Incomplete: ... + def addConsLocal( + self, cons: Incomplete, validnode: Incomplete = ... + ) -> Incomplete: ... + def addConsNode( + self, node: Incomplete, cons: Incomplete, validnode: Incomplete = ... + ) -> Incomplete: ... + def addConsOr( + self, + vars: Incomplete, + resvar: Incomplete, + name: Incomplete = ..., + initial: Incomplete = ..., + separate: Incomplete = ..., + enforce: Incomplete = ..., + check: Incomplete = ..., + propagate: Incomplete = ..., + local: Incomplete = ..., + modifiable: Incomplete = ..., + dynamic: Incomplete = ..., + removable: Incomplete = ..., + stickingatnode: Incomplete = ..., + ) -> Incomplete: ... + def addConsSOS1( + self, + vars: Incomplete, + weights: Incomplete = ..., + name: Incomplete = ..., + initial: Incomplete = ..., + separate: Incomplete = ..., + enforce: Incomplete = ..., + check: Incomplete = ..., + propagate: Incomplete = ..., + local: Incomplete = ..., + dynamic: Incomplete = ..., + removable: Incomplete = ..., + stickingatnode: Incomplete = ..., + ) -> Incomplete: ... + def addConsSOS2( + self, + vars: Incomplete, + weights: Incomplete = ..., + name: Incomplete = ..., + initial: Incomplete = ..., + separate: Incomplete = ..., + enforce: Incomplete = ..., + check: Incomplete = ..., + propagate: Incomplete = ..., + local: Incomplete = ..., + dynamic: Incomplete = ..., + removable: Incomplete = ..., + stickingatnode: Incomplete = ..., + ) -> Incomplete: ... + def addConsXor( + self, + vars: Incomplete, + rhsvar: Incomplete, + name: Incomplete = ..., + initial: Incomplete = ..., + separate: Incomplete = ..., + enforce: Incomplete = ..., + check: Incomplete = ..., + propagate: Incomplete = ..., + local: Incomplete = ..., + modifiable: Incomplete = ..., + dynamic: Incomplete = ..., + removable: Incomplete = ..., + stickingatnode: Incomplete = ..., + ) -> Incomplete: ... + def addConss( + self, + conss: Incomplete, + name: Incomplete = ..., + initial: Incomplete = ..., + separate: Incomplete = ..., + enforce: Incomplete = ..., + check: Incomplete = ..., + propagate: Incomplete = ..., + local: Incomplete = ..., + modifiable: Incomplete = ..., + dynamic: Incomplete = ..., + removable: Incomplete = ..., + stickingatnode: Incomplete = ..., + ) -> Incomplete: ... def addCut(self, cut: Incomplete, forcecut: Incomplete = ...) -> Incomplete: ... - def addExprNonlinear(self, cons: Incomplete, expr: Incomplete, coef: Incomplete) -> Incomplete: ... - def addMatrixCons(self, cons: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... - def addMatrixConsIndicator(self, cons: Incomplete, binvar: Incomplete = ..., activeone: Incomplete = ..., name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... - def addMatrixVar(self, shape: Incomplete, name: Incomplete = ..., vtype: Incomplete = ..., lb: Incomplete = ..., ub: Incomplete = ..., obj: Incomplete = ..., pricedVar: Incomplete = ..., pricedVarScore: Incomplete = ...) -> Incomplete: ... - def addObjoffset(self, offset: Incomplete, solutions: Incomplete = ...) -> Incomplete: ... + def addExprNonlinear( + self, cons: Incomplete, expr: Incomplete, coef: Incomplete + ) -> Incomplete: ... + def addMatrixCons( + self, + cons: Incomplete, + name: Incomplete = ..., + initial: Incomplete = ..., + separate: Incomplete = ..., + enforce: Incomplete = ..., + check: Incomplete = ..., + propagate: Incomplete = ..., + local: Incomplete = ..., + modifiable: Incomplete = ..., + dynamic: Incomplete = ..., + removable: Incomplete = ..., + stickingatnode: Incomplete = ..., + ) -> Incomplete: ... + def addMatrixConsIndicator( + self, + cons: Incomplete, + binvar: Incomplete = ..., + activeone: Incomplete = ..., + name: Incomplete = ..., + initial: Incomplete = ..., + separate: Incomplete = ..., + enforce: Incomplete = ..., + check: Incomplete = ..., + propagate: Incomplete = ..., + local: Incomplete = ..., + dynamic: Incomplete = ..., + removable: Incomplete = ..., + stickingatnode: Incomplete = ..., + ) -> Incomplete: ... + def addMatrixVar( + self, + shape: Incomplete, + name: Incomplete = ..., + vtype: Incomplete = ..., + lb: Incomplete = ..., + ub: Incomplete = ..., + obj: Incomplete = ..., + pricedVar: Incomplete = ..., + pricedVarScore: Incomplete = ..., + ) -> Incomplete: ... + def addObjoffset( + self, offset: Incomplete, solutions: Incomplete = ... + ) -> Incomplete: ... def addPoolCut(self, row: Incomplete) -> Incomplete: ... def addPyCons(self, cons: Incomplete) -> Incomplete: ... def addRowDive(self, row: Incomplete) -> Incomplete: ... def addRowExact(self, rowexact: Incomplete) -> Incomplete: ... def addSol(self, solution: Incomplete, free: Incomplete = ...) -> Incomplete: ... - def addVar(self, name: Incomplete = ..., vtype: Incomplete = ..., lb: Incomplete = ..., ub: Incomplete = ..., obj: Incomplete = ..., pricedVar: Incomplete = ..., pricedVarScore: Incomplete = ..., deletable: Incomplete = ...) -> Incomplete: ... - def addVarLocks(self, var: Incomplete, nlocksdown: Incomplete, nlocksup: Incomplete) -> Incomplete: ... - def addVarLocksType(self, var: Incomplete, locktype: Incomplete, nlocksdown: Incomplete, nlocksup: Incomplete) -> Incomplete: ... - def addVarSOS1(self, cons: Incomplete, var: Incomplete, weight: Incomplete) -> Incomplete: ... - def addVarSOS2(self, cons: Incomplete, var: Incomplete, weight: Incomplete) -> Incomplete: ... - def addVarToRow(self, row: Incomplete, var: Incomplete, value: Incomplete) -> Incomplete: ... + def addVar( + self, + name: Incomplete = ..., + vtype: Incomplete = ..., + lb: Incomplete = ..., + ub: Incomplete = ..., + obj: Incomplete = ..., + pricedVar: Incomplete = ..., + pricedVarScore: Incomplete = ..., + deletable: Incomplete = ..., + ) -> Incomplete: ... + def addVarLocks( + self, var: Incomplete, nlocksdown: Incomplete, nlocksup: Incomplete + ) -> Incomplete: ... + def addVarLocksType( + self, + var: Incomplete, + locktype: Incomplete, + nlocksdown: Incomplete, + nlocksup: Incomplete, + ) -> Incomplete: ... + def addVarSOS1( + self, cons: Incomplete, var: Incomplete, weight: Incomplete + ) -> Incomplete: ... + def addVarSOS2( + self, cons: Incomplete, var: Incomplete, weight: Incomplete + ) -> Incomplete: ... + def addVarToRow( + self, row: Incomplete, var: Incomplete, value: Incomplete + ) -> Incomplete: ... def allColsInLP(self) -> Incomplete: ... def allowNegSlackExact(self) -> Incomplete: ... def appendVarSOS1(self, cons: Incomplete, var: Incomplete) -> Incomplete: ... def appendVarSOS2(self, cons: Incomplete, var: Incomplete) -> Incomplete: ... def applyCutsProbing(self) -> Incomplete: ... - def attachEventHandlerCallback(self, callback: Incomplete, events: Incomplete, name: Incomplete = ..., description: Incomplete = ...) -> Incomplete: ... + def attachEventHandlerCallback( + self, + callback: Incomplete, + events: Incomplete, + name: Incomplete = ..., + description: Incomplete = ..., + ) -> Incomplete: ... def backtrackProbing(self, probingdepth: Incomplete) -> Incomplete: ... def branchLPExact(self) -> Incomplete: ... def branchVar(self, variable: Incomplete) -> Incomplete: ... def branchVarVal(self, variable: Incomplete, value: Incomplete) -> Incomplete: ... def cacheRowExtensions(self, row: Incomplete) -> Incomplete: ... - def calcChildEstimate(self, variable: Incomplete, targetvalue: Incomplete) -> Incomplete: ... - def calcNodeselPriority(self, variable: Incomplete, branchdir: Incomplete, targetvalue: Incomplete) -> Incomplete: ... - def catchEvent(self, eventtype: Incomplete, eventhdlr: Incomplete) -> Incomplete: ... - def catchRowEvent(self, row: Incomplete, eventtype: Incomplete, eventhdlr: Incomplete) -> Incomplete: ... - def catchVarEvent(self, var: Incomplete, eventtype: Incomplete, eventhdlr: Incomplete) -> Incomplete: ... - def checkBendersSubproblemOptimality(self, solution: Incomplete, probnumber: Incomplete, benders: Incomplete = ...) -> Incomplete: ... + def calcChildEstimate( + self, variable: Incomplete, targetvalue: Incomplete + ) -> Incomplete: ... + def calcNodeselPriority( + self, variable: Incomplete, branchdir: Incomplete, targetvalue: Incomplete + ) -> Incomplete: ... + def catchEvent( + self, eventtype: Incomplete, eventhdlr: Incomplete + ) -> Incomplete: ... + def catchRowEvent( + self, row: Incomplete, eventtype: Incomplete, eventhdlr: Incomplete + ) -> Incomplete: ... + def catchVarEvent( + self, var: Incomplete, eventtype: Incomplete, eventhdlr: Incomplete + ) -> Incomplete: ... + def checkBendersSubproblemOptimality( + self, solution: Incomplete, probnumber: Incomplete, benders: Incomplete = ... + ) -> Incomplete: ... def checkQuadraticNonlinear(self, cons: Incomplete) -> Incomplete: ... - def checkSol(self, solution: Incomplete, printreason: Incomplete = ..., completely: Incomplete = ..., checkbounds: Incomplete = ..., checkintegrality: Incomplete = ..., checklprows: Incomplete = ..., original: Incomplete = ...) -> Incomplete: ... - def chgCapacityKnapsack(self, cons: Incomplete, capacity: Incomplete) -> Incomplete: ... - def chgCoefLinear(self, cons: Incomplete, var: Incomplete, value: Incomplete) -> Incomplete: ... + def checkSol( + self, + solution: Incomplete, + printreason: Incomplete = ..., + completely: Incomplete = ..., + checkbounds: Incomplete = ..., + checkintegrality: Incomplete = ..., + checklprows: Incomplete = ..., + original: Incomplete = ..., + ) -> Incomplete: ... + def chgCapacityKnapsack( + self, cons: Incomplete, capacity: Incomplete + ) -> Incomplete: ... + def chgCoefLinear( + self, cons: Incomplete, var: Incomplete, value: Incomplete + ) -> Incomplete: ... def chgLhs(self, cons: Incomplete, lhs: Incomplete) -> Incomplete: ... - def chgReoptObjective(self, coeffs: Incomplete, sense: Incomplete = ...) -> Incomplete: ... + def chgReoptObjective( + self, coeffs: Incomplete, sense: Incomplete = ... + ) -> Incomplete: ... def chgRhs(self, cons: Incomplete, rhs: Incomplete) -> Incomplete: ... def chgRowLhsDive(self, row: Incomplete, newlhs: Incomplete) -> Incomplete: ... def chgRowRhsDive(self, row: Incomplete, newrhs: Incomplete) -> Incomplete: ... - def chgVarBranchPriority(self, var: Incomplete, priority: Incomplete) -> Incomplete: ... + def chgVarBranchPriority( + self, var: Incomplete, priority: Incomplete + ) -> Incomplete: ... def chgVarLb(self, var: Incomplete, lb: Incomplete) -> Incomplete: ... def chgVarLbDive(self, var: Incomplete, newbound: Incomplete) -> Incomplete: ... def chgVarLbGlobal(self, var: Incomplete, lb: Incomplete) -> Incomplete: ... - def chgVarLbNode(self, node: Incomplete, var: Incomplete, lb: Incomplete) -> Incomplete: ... + def chgVarLbNode( + self, node: Incomplete, var: Incomplete, lb: Incomplete + ) -> Incomplete: ... def chgVarLbProbing(self, var: Incomplete, lb: Incomplete) -> Incomplete: ... def chgVarObjDive(self, var: Incomplete, newobj: Incomplete) -> Incomplete: ... def chgVarObjProbing(self, var: Incomplete, newobj: Incomplete) -> Incomplete: ... @@ -520,21 +918,74 @@ class Model: def chgVarUb(self, var: Incomplete, ub: Incomplete) -> Incomplete: ... def chgVarUbDive(self, var: Incomplete, newbound: Incomplete) -> Incomplete: ... def chgVarUbGlobal(self, var: Incomplete, ub: Incomplete) -> Incomplete: ... - def chgVarUbNode(self, node: Incomplete, var: Incomplete, ub: Incomplete) -> Incomplete: ... + def chgVarUbNode( + self, node: Incomplete, var: Incomplete, ub: Incomplete + ) -> Incomplete: ... def chgVarUbProbing(self, var: Incomplete, ub: Incomplete) -> Incomplete: ... def computeBestSolSubproblems(self) -> Incomplete: ... def constructLP(self) -> Incomplete: ... - def copyLargeNeighborhoodSearch(self, to_fix: Incomplete, fix_vals: Incomplete) -> Incomplete: ... + def copyLargeNeighborhoodSearch( + self, to_fix: Incomplete, fix_vals: Incomplete + ) -> Incomplete: ... def count(self) -> Incomplete: ... - def createChild(self, nodeselprio: Incomplete, estimate: Incomplete) -> Incomplete: ... - def createCons(self, conshdlr: Incomplete, name: Incomplete, initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... - def createConsFromExpr(self, cons: Incomplete, name: Incomplete = ..., initial: Incomplete = ..., separate: Incomplete = ..., enforce: Incomplete = ..., check: Incomplete = ..., propagate: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., dynamic: Incomplete = ..., removable: Incomplete = ..., stickingatnode: Incomplete = ...) -> Incomplete: ... - def createEmptyRowSepa(self, sepa: Incomplete, name: Incomplete = ..., lhs: Incomplete = ..., rhs: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., removable: Incomplete = ...) -> Incomplete: ... - def createEmptyRowUnspec(self, name: Incomplete = ..., lhs: Incomplete = ..., rhs: Incomplete = ..., local: Incomplete = ..., modifiable: Incomplete = ..., removable: Incomplete = ...) -> Incomplete: ... + def createChild( + self, nodeselprio: Incomplete, estimate: Incomplete + ) -> Incomplete: ... + def createCons( + self, + conshdlr: Incomplete, + name: Incomplete, + initial: Incomplete = ..., + separate: Incomplete = ..., + enforce: Incomplete = ..., + check: Incomplete = ..., + propagate: Incomplete = ..., + local: Incomplete = ..., + modifiable: Incomplete = ..., + dynamic: Incomplete = ..., + removable: Incomplete = ..., + stickingatnode: Incomplete = ..., + ) -> Incomplete: ... + def createConsFromExpr( + self, + cons: Incomplete, + name: Incomplete = ..., + initial: Incomplete = ..., + separate: Incomplete = ..., + enforce: Incomplete = ..., + check: Incomplete = ..., + propagate: Incomplete = ..., + local: Incomplete = ..., + modifiable: Incomplete = ..., + dynamic: Incomplete = ..., + removable: Incomplete = ..., + stickingatnode: Incomplete = ..., + ) -> Incomplete: ... + def createEmptyRowSepa( + self, + sepa: Incomplete, + name: Incomplete = ..., + lhs: Incomplete = ..., + rhs: Incomplete = ..., + local: Incomplete = ..., + modifiable: Incomplete = ..., + removable: Incomplete = ..., + ) -> Incomplete: ... + def createEmptyRowUnspec( + self, + name: Incomplete = ..., + lhs: Incomplete = ..., + rhs: Incomplete = ..., + local: Incomplete = ..., + modifiable: Incomplete = ..., + removable: Incomplete = ..., + ) -> Incomplete: ... def createOrigSol(self, heur: Incomplete = ...) -> Incomplete: ... def createPartialSol(self, heur: Incomplete = ...) -> Incomplete: ... def createProbBasic(self, problemName: Incomplete = ...) -> Incomplete: ... - def createSol(self, heur: Incomplete = ..., initlp: Incomplete = ...) -> Incomplete: ... + def createSol( + self, heur: Incomplete = ..., initlp: Incomplete = ... + ) -> Incomplete: ... def cutoffNode(self, node: Incomplete) -> Incomplete: ... def deactivatePricer(self, pricer: Incomplete) -> Incomplete: ... def delCoefLinear(self, cons: Incomplete, var: Incomplete) -> Incomplete: ... @@ -544,8 +995,12 @@ class Model: def disableDebugSol(self) -> Incomplete: ... def disablePropagation(self, onlyroot: Incomplete = ...) -> Incomplete: ... def dropEvent(self, eventtype: Incomplete, eventhdlr: Incomplete) -> Incomplete: ... - def dropRowEvent(self, row: Incomplete, eventtype: Incomplete, eventhdlr: Incomplete) -> Incomplete: ... - def dropVarEvent(self, var: Incomplete, eventtype: Incomplete, eventhdlr: Incomplete) -> Incomplete: ... + def dropRowEvent( + self, row: Incomplete, eventtype: Incomplete, eventhdlr: Incomplete + ) -> Incomplete: ... + def dropVarEvent( + self, var: Incomplete, eventtype: Incomplete, eventhdlr: Incomplete + ) -> Incomplete: ... def enableDebugSol(self) -> Incomplete: ... def enableExactSolving(self, enable: Incomplete) -> Incomplete: ... def enableReoptimization(self, enable: Incomplete = ...) -> Incomplete: ... @@ -571,17 +1026,32 @@ class Model: def from_ptr(capsule: Incomplete, take_ownership: Incomplete) -> Incomplete: ... def generateIIS(self) -> Incomplete: ... def getActivity(self, cons: Incomplete, sol: Incomplete = ...) -> Incomplete: ... - def getBendersAuxiliaryVar(self, probnumber: Incomplete, benders: Incomplete = ...) -> Incomplete: ... - def getBendersSubproblem(self, probnumber: Incomplete, benders: Incomplete = ...) -> Incomplete: ... - def getBendersVar(self, var: Incomplete, benders: Incomplete = ..., probnumber: Incomplete = ...) -> Incomplete: ... + def getBendersAuxiliaryVar( + self, probnumber: Incomplete, benders: Incomplete = ... + ) -> Incomplete: ... + def getBendersSubproblem( + self, probnumber: Incomplete, benders: Incomplete = ... + ) -> Incomplete: ... + def getBendersVar( + self, var: Incomplete, benders: Incomplete = ..., probnumber: Incomplete = ... + ) -> Incomplete: ... def getBestChild(self) -> Incomplete: ... def getBestLeaf(self) -> Incomplete: ... def getBestNode(self) -> Incomplete: ... def getBestSibling(self) -> Incomplete: ... def getBestSol(self) -> Incomplete: ... def getBestboundNode(self) -> Incomplete: ... - def getBipartiteGraphRepresentation(self, prev_col_features: Incomplete = ..., prev_edge_features: Incomplete = ..., prev_row_features: Incomplete = ..., static_only: Incomplete = ..., suppress_warnings: Incomplete = ...) -> Incomplete: ... - def getBranchScoreMultiple(self, var: Incomplete, gains: Incomplete) -> Incomplete: ... + def getBipartiteGraphRepresentation( + self, + prev_col_features: Incomplete = ..., + prev_edge_features: Incomplete = ..., + prev_row_features: Incomplete = ..., + static_only: Incomplete = ..., + suppress_warnings: Incomplete = ..., + ) -> Incomplete: ... + def getBranchScoreMultiple( + self, var: Incomplete, gains: Incomplete + ) -> Incomplete: ... def getCapacityKnapsack(self, cons: Incomplete) -> Incomplete: ... def getChildren(self) -> Incomplete: ... def getColRedCost(self, col: Incomplete) -> Incomplete: ... @@ -592,11 +1062,15 @@ class Model: def getConss(self, transformed: Incomplete = ...) -> Incomplete: ... def getCurrentNode(self) -> Incomplete: ... def getCutEfficacy(self, cut: Incomplete, sol: Incomplete = ...) -> Incomplete: ... - def getCutLPSolCutoffDistance(self, cut: Incomplete, sol: Incomplete) -> Incomplete: ... + def getCutLPSolCutoffDistance( + self, cut: Incomplete, sol: Incomplete + ) -> Incomplete: ... def getCutoffbound(self) -> Incomplete: ... def getDepth(self) -> Incomplete: ... def getDualMultiplier(self, cons: Incomplete) -> Incomplete: ... - def getDualSolVal(self, cons: Incomplete, boundconstraint: Incomplete = ...) -> Incomplete: ... + def getDualSolVal( + self, cons: Incomplete, boundconstraint: Incomplete = ... + ) -> Incomplete: ... def getDualbound(self) -> Incomplete: ... def getDualboundRoot(self) -> Incomplete: ... def getDualfarkasKnapsack(self, cons: Incomplete) -> Incomplete: ... @@ -654,8 +1128,12 @@ class Model: def getNVars(self, transformed: Incomplete = ...) -> Incomplete: ... def getNVarsAnd(self, and_cons: Incomplete) -> Incomplete: ... def getNlRowActivityBounds(self, nlrow: Incomplete) -> Incomplete: ... - def getNlRowSolActivity(self, nlrow: Incomplete, sol: Incomplete = ...) -> Incomplete: ... - def getNlRowSolFeasibility(self, nlrow: Incomplete, sol: Incomplete = ...) -> Incomplete: ... + def getNlRowSolActivity( + self, nlrow: Incomplete, sol: Incomplete = ... + ) -> Incomplete: ... + def getNlRowSolFeasibility( + self, nlrow: Incomplete, sol: Incomplete = ... + ) -> Incomplete: ... def getNlRows(self) -> Incomplete: ... def getObjVal(self, original: Incomplete = ...) -> Incomplete: ... def getObjective(self) -> Incomplete: ... @@ -684,11 +1162,17 @@ class Model: def getRowLinear(self, cons: Incomplete) -> Incomplete: ... def getRowNumIntCols(self, row: Incomplete) -> Incomplete: ... def getRowObjParallelism(self, row: Incomplete) -> Incomplete: ... - def getRowParallelism(self, row1: Incomplete, row2: Incomplete, orthofunc: Incomplete = ...) -> Incomplete: ... + def getRowParallelism( + self, row1: Incomplete, row2: Incomplete, orthofunc: Incomplete = ... + ) -> Incomplete: ... def getSiblings(self) -> Incomplete: ... - def getSlack(self, cons: Incomplete, sol: Incomplete = ..., side: Incomplete = ...) -> Incomplete: ... + def getSlack( + self, cons: Incomplete, sol: Incomplete = ..., side: Incomplete = ... + ) -> Incomplete: ... def getSlackVarIndicator(self, cons: Incomplete) -> Incomplete: ... - def getSolObjVal(self, sol: Incomplete, original: Incomplete = ...) -> Incomplete: ... + def getSolObjVal( + self, sol: Incomplete, original: Incomplete = ... + ) -> Incomplete: ... def getSolTime(self, sol: Incomplete) -> Incomplete: ... def getSolVal(self, sol: Incomplete, expr: Incomplete) -> Incomplete: ... def getSols(self) -> Incomplete: ... @@ -706,10 +1190,20 @@ class Model: def getValsLinear(self, cons: Incomplete) -> Incomplete: ... def getVarDict(self, transformed: Incomplete = ...) -> Incomplete: ... def getVarLbDive(self, var: Incomplete) -> Incomplete: ... - def getVarPseudocost(self, var: Incomplete, branchdir: Incomplete) -> Incomplete: ... - def getVarPseudocostScore(self, var: Incomplete, solVal: Incomplete) -> Incomplete: ... + def getVarPseudocost( + self, var: Incomplete, branchdir: Incomplete + ) -> Incomplete: ... + def getVarPseudocostScore( + self, var: Incomplete, solVal: Incomplete + ) -> Incomplete: ... def getVarRedcost(self, var: Incomplete) -> Incomplete: ... - def getVarStrongbranch(self, var: Incomplete, itlim: Incomplete, idempotent: Incomplete = ..., integral: Incomplete = ...) -> Incomplete: ... + def getVarStrongbranch( + self, + var: Incomplete, + itlim: Incomplete, + idempotent: Incomplete = ..., + integral: Incomplete = ..., + ) -> Incomplete: ... def getVarStrongbranchLast(self, var: Incomplete) -> Incomplete: ... def getVarStrongbranchNode(self, var: Incomplete) -> Incomplete: ... def getVarUbDive(self, var: Incomplete) -> Incomplete: ... @@ -720,28 +1214,153 @@ class Model: def hideOutput(self, quiet: Incomplete = ...) -> Incomplete: ... def inProbing(self) -> Incomplete: ... def inRepropagation(self) -> Incomplete: ... - def includeBenders(self, benders: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete = ..., cutlp: Incomplete = ..., cutpseudo: Incomplete = ..., cutrelax: Incomplete = ..., shareaux: Incomplete = ...) -> Incomplete: ... + def includeBenders( + self, + benders: Incomplete, + name: Incomplete, + desc: Incomplete, + priority: Incomplete = ..., + cutlp: Incomplete = ..., + cutpseudo: Incomplete = ..., + cutrelax: Incomplete = ..., + shareaux: Incomplete = ..., + ) -> Incomplete: ... def includeBendersDefaultCuts(self, benders: Incomplete) -> Incomplete: ... - def includeBenderscut(self, benders: Incomplete, benderscut: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete = ..., islpcut: Incomplete = ...) -> Incomplete: ... - def includeBranchrule(self, branchrule: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete, maxdepth: Incomplete, maxbounddist: Incomplete) -> Incomplete: ... - def includeConshdlr(self, conshdlr: Incomplete, name: Incomplete, desc: Incomplete, sepapriority: Incomplete = ..., enfopriority: Incomplete = ..., chckpriority: Incomplete = ..., sepafreq: Incomplete = ..., propfreq: Incomplete = ..., eagerfreq: Incomplete = ..., maxprerounds: Incomplete = ..., delaysepa: Incomplete = ..., delayprop: Incomplete = ..., needscons: Incomplete = ..., proptiming: Incomplete = ..., presoltiming: Incomplete = ...) -> Incomplete: ... - def includeCutsel(self, cutsel: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete) -> Incomplete: ... + def includeBenderscut( + self, + benders: Incomplete, + benderscut: Incomplete, + name: Incomplete, + desc: Incomplete, + priority: Incomplete = ..., + islpcut: Incomplete = ..., + ) -> Incomplete: ... + def includeBranchrule( + self, + branchrule: Incomplete, + name: Incomplete, + desc: Incomplete, + priority: Incomplete, + maxdepth: Incomplete, + maxbounddist: Incomplete, + ) -> Incomplete: ... + def includeConshdlr( + self, + conshdlr: Incomplete, + name: Incomplete, + desc: Incomplete, + sepapriority: Incomplete = ..., + enfopriority: Incomplete = ..., + chckpriority: Incomplete = ..., + sepafreq: Incomplete = ..., + propfreq: Incomplete = ..., + eagerfreq: Incomplete = ..., + maxprerounds: Incomplete = ..., + delaysepa: Incomplete = ..., + delayprop: Incomplete = ..., + needscons: Incomplete = ..., + proptiming: Incomplete = ..., + presoltiming: Incomplete = ..., + ) -> Incomplete: ... + def includeCutsel( + self, + cutsel: Incomplete, + name: Incomplete, + desc: Incomplete, + priority: Incomplete, + ) -> Incomplete: ... def includeDefaultPlugins(self) -> Incomplete: ... - def includeEventhdlr(self, eventhdlr: Incomplete, name: Incomplete, desc: Incomplete) -> Incomplete: ... - def includeHeur(self, heur: Incomplete, name: Incomplete, desc: Incomplete, dispchar: Incomplete, priority: Incomplete = ..., freq: Incomplete = ..., freqofs: Incomplete = ..., maxdepth: Incomplete = ..., timingmask: Incomplete = ..., usessubscip: Incomplete = ...) -> Incomplete: ... - def includeIISfinder(self, iisfinder: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete = ..., freq: Incomplete = ...) -> Incomplete: ... - def includeNodesel(self, nodesel: Incomplete, name: Incomplete, desc: Incomplete, stdpriority: Incomplete, memsavepriority: Incomplete) -> Incomplete: ... - def includePresol(self, presol: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete, maxrounds: Incomplete, timing: Incomplete = ...) -> Incomplete: ... - def includePricer(self, pricer: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete = ..., delay: Incomplete = ...) -> Incomplete: ... - def includeProp(self, prop: Incomplete, name: Incomplete, desc: Incomplete, presolpriority: Incomplete, presolmaxrounds: Incomplete, proptiming: Incomplete, presoltiming: Incomplete = ..., priority: Incomplete = ..., freq: Incomplete = ..., delay: Incomplete = ...) -> Incomplete: ... - def includeReader(self, reader: Incomplete, name: Incomplete, desc: Incomplete, ext: Incomplete) -> Incomplete: ... - def includeRelax(self, relax: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete = ..., freq: Incomplete = ...) -> Incomplete: ... - def includeSepa(self, sepa: Incomplete, name: Incomplete, desc: Incomplete, priority: Incomplete = ..., freq: Incomplete = ..., maxbounddist: Incomplete = ..., usessubscip: Incomplete = ..., delay: Incomplete = ...) -> Incomplete: ... + def includeEventhdlr( + self, eventhdlr: Incomplete, name: Incomplete, desc: Incomplete + ) -> Incomplete: ... + def includeHeur( + self, + heur: Incomplete, + name: Incomplete, + desc: Incomplete, + dispchar: Incomplete, + priority: Incomplete = ..., + freq: Incomplete = ..., + freqofs: Incomplete = ..., + maxdepth: Incomplete = ..., + timingmask: Incomplete = ..., + usessubscip: Incomplete = ..., + ) -> Incomplete: ... + def includeIISfinder( + self, + iisfinder: Incomplete, + name: Incomplete, + desc: Incomplete, + priority: Incomplete = ..., + freq: Incomplete = ..., + ) -> Incomplete: ... + def includeNodesel( + self, + nodesel: Incomplete, + name: Incomplete, + desc: Incomplete, + stdpriority: Incomplete, + memsavepriority: Incomplete, + ) -> Incomplete: ... + def includePresol( + self, + presol: Incomplete, + name: Incomplete, + desc: Incomplete, + priority: Incomplete, + maxrounds: Incomplete, + timing: Incomplete = ..., + ) -> Incomplete: ... + def includePricer( + self, + pricer: Incomplete, + name: Incomplete, + desc: Incomplete, + priority: Incomplete = ..., + delay: Incomplete = ..., + ) -> Incomplete: ... + def includeProp( + self, + prop: Incomplete, + name: Incomplete, + desc: Incomplete, + presolpriority: Incomplete, + presolmaxrounds: Incomplete, + proptiming: Incomplete, + presoltiming: Incomplete = ..., + priority: Incomplete = ..., + freq: Incomplete = ..., + delay: Incomplete = ..., + ) -> Incomplete: ... + def includeReader( + self, reader: Incomplete, name: Incomplete, desc: Incomplete, ext: Incomplete + ) -> Incomplete: ... + def includeRelax( + self, + relax: Incomplete, + name: Incomplete, + desc: Incomplete, + priority: Incomplete = ..., + freq: Incomplete = ..., + ) -> Incomplete: ... + def includeSepa( + self, + sepa: Incomplete, + name: Incomplete, + desc: Incomplete, + priority: Incomplete = ..., + freq: Incomplete = ..., + maxbounddist: Incomplete = ..., + usessubscip: Incomplete = ..., + delay: Incomplete = ..., + ) -> Incomplete: ... def infinity(self) -> Incomplete: ... def initBendersDefault(self, subproblems: Incomplete) -> Incomplete: ... def interruptSolve(self) -> Incomplete: ... def isAndConsSorted(self, and_cons: Incomplete) -> Incomplete: ... - def isCutEfficacious(self, cut: Incomplete, sol: Incomplete = ...) -> Incomplete: ... + def isCutEfficacious( + self, cut: Incomplete, sol: Incomplete = ... + ) -> Incomplete: ... def isEQ(self, val1: Incomplete, val2: Incomplete) -> Incomplete: ... def isExact(self) -> Incomplete: ... def isFeasEQ(self, val1: Incomplete, val2: Incomplete) -> Incomplete: ... @@ -776,15 +1395,24 @@ class Model: def printCons(self, constraint: Incomplete) -> Incomplete: ... def printExternalCodeVersions(self) -> Incomplete: ... def printNlRow(self, nlrow: Incomplete) -> Incomplete: ... - def printProblem(self, ext: Incomplete = ..., trans: Incomplete = ..., genericnames: Incomplete = ...) -> Incomplete: ... + def printProblem( + self, + ext: Incomplete = ..., + trans: Incomplete = ..., + genericnames: Incomplete = ..., + ) -> Incomplete: ... def printRow(self, row: Incomplete) -> Incomplete: ... - def printSol(self, solution: Incomplete = ..., write_zeros: Incomplete = ...) -> Incomplete: ... + def printSol( + self, solution: Incomplete = ..., write_zeros: Incomplete = ... + ) -> Incomplete: ... def printStatistics(self, filename: Incomplete = ...) -> Incomplete: ... def printStatisticsJson(self) -> Incomplete: ... def printVersion(self) -> Incomplete: ... def propagateProbing(self, maxproprounds: Incomplete) -> Incomplete: ... def readParams(self, file: Incomplete) -> Incomplete: ... - def readProblem(self, filename: Incomplete, extension: Incomplete = ...) -> Incomplete: ... + def readProblem( + self, filename: Incomplete, extension: Incomplete = ... + ) -> Incomplete: ... def readSol(self, filename: Incomplete) -> Incomplete: ... def readSolFile(self, filename: Incomplete) -> Incomplete: ... def redirectOutput(self) -> Incomplete: ... @@ -794,14 +1422,26 @@ class Model: def resetParam(self, name: Incomplete) -> Incomplete: ... def resetParams(self) -> Incomplete: ... def restartSolve(self) -> Incomplete: ... - def separateSol(self, sol: Incomplete = ..., pretendroot: Incomplete = ..., allowlocal: Incomplete = ..., onlydelayed: Incomplete = ...) -> Incomplete: ... - def setBendersSubproblemIsConvex(self, benders: Incomplete, probnumber: Incomplete, isconvex: Incomplete = ...) -> Incomplete: ... + def separateSol( + self, + sol: Incomplete = ..., + pretendroot: Incomplete = ..., + allowlocal: Incomplete = ..., + onlydelayed: Incomplete = ..., + ) -> Incomplete: ... + def setBendersSubproblemIsConvex( + self, benders: Incomplete, probnumber: Incomplete, isconvex: Incomplete = ... + ) -> Incomplete: ... def setBoolParam(self, name: Incomplete, value: Incomplete) -> Incomplete: ... def setCharParam(self, name: Incomplete, value: Incomplete) -> Incomplete: ... def setCheck(self, cons: Incomplete, newCheck: Incomplete) -> Incomplete: ... - def setEmphasis(self, paraemphasis: Incomplete, quiet: Incomplete = ...) -> Incomplete: ... + def setEmphasis( + self, paraemphasis: Incomplete, quiet: Incomplete = ... + ) -> Incomplete: ... def setEnforced(self, cons: Incomplete, newEnf: Incomplete) -> Incomplete: ... - def setHeurTiming(self, heurname: Incomplete, heurtiming: Incomplete) -> Incomplete: ... + def setHeurTiming( + self, heurname: Incomplete, heurtiming: Incomplete + ) -> Incomplete: ... def setHeuristics(self, setting: Incomplete) -> Incomplete: ... def setInitial(self, cons: Incomplete, newInit: Incomplete) -> Incomplete: ... def setIntParam(self, name: Incomplete, value: Incomplete) -> Incomplete: ... @@ -811,7 +1451,9 @@ class Model: def setMinimize(self) -> Incomplete: ... def setModifiable(self, cons: Incomplete, newMod: Incomplete) -> Incomplete: ... def setObjIntegral(self) -> Incomplete: ... - def setObjective(self, expr: Incomplete, sense: Incomplete = ..., clear: Incomplete = ...) -> Incomplete: ... + def setObjective( + self, expr: Incomplete, sense: Incomplete = ..., clear: Incomplete = ... + ) -> Incomplete: ... def setObjlimit(self, objlimit: Incomplete) -> Incomplete: ... def setParam(self, name: Incomplete, value: Incomplete) -> Incomplete: ... def setParams(self, params: Incomplete) -> Incomplete: ... @@ -822,10 +1464,24 @@ class Model: def setRelaxSolVal(self, var: Incomplete, val: Incomplete) -> Incomplete: ... def setRemovable(self, cons: Incomplete, newRem: Incomplete) -> Incomplete: ... def setSeparating(self, setting: Incomplete) -> Incomplete: ... - def setSolVal(self, solution: Incomplete, var: Incomplete, val: Incomplete) -> Incomplete: ... + def setSolVal( + self, solution: Incomplete, var: Incomplete, val: Incomplete + ) -> Incomplete: ... def setStringParam(self, name: Incomplete, value: Incomplete) -> Incomplete: ... - def setupBendersSubproblem(self, probnumber: Incomplete, benders: Incomplete = ..., solution: Incomplete = ..., checktype: Incomplete = ...) -> Incomplete: ... - def solveBendersSubproblem(self, probnumber: Incomplete, solvecip: Incomplete, benders: Incomplete = ..., solution: Incomplete = ...) -> Incomplete: ... + def setupBendersSubproblem( + self, + probnumber: Incomplete, + benders: Incomplete = ..., + solution: Incomplete = ..., + checktype: Incomplete = ..., + ) -> Incomplete: ... + def solveBendersSubproblem( + self, + probnumber: Incomplete, + solvecip: Incomplete, + benders: Incomplete = ..., + solution: Incomplete = ..., + ) -> Incomplete: ... def solveConcurrent(self) -> Incomplete: ... def solveDiveLP(self, itlim: Incomplete = ...) -> Incomplete: ... def solveProbingLP(self, itlim: Incomplete = ...) -> Incomplete: ... @@ -833,28 +1489,87 @@ class Model: def startDive(self) -> Incomplete: ... def startProbing(self) -> Incomplete: ... def startStrongbranch(self) -> Incomplete: ... - def tightenVarLb(self, var: Incomplete, lb: Incomplete, force: Incomplete = ...) -> Incomplete: ... - def tightenVarLbGlobal(self, var: Incomplete, lb: Incomplete, force: Incomplete = ...) -> Incomplete: ... - def tightenVarUb(self, var: Incomplete, ub: Incomplete, force: Incomplete = ...) -> Incomplete: ... - def tightenVarUbGlobal(self, var: Incomplete, ub: Incomplete, force: Incomplete = ...) -> Incomplete: ... + def tightenVarLb( + self, var: Incomplete, lb: Incomplete, force: Incomplete = ... + ) -> Incomplete: ... + def tightenVarLbGlobal( + self, var: Incomplete, lb: Incomplete, force: Incomplete = ... + ) -> Incomplete: ... + def tightenVarUb( + self, var: Incomplete, ub: Incomplete, force: Incomplete = ... + ) -> Incomplete: ... + def tightenVarUbGlobal( + self, var: Incomplete, ub: Incomplete, force: Incomplete = ... + ) -> Incomplete: ... def to_ptr(self, give_ownership: Incomplete) -> Incomplete: ... - def translateSubSol(self, sub_model: Incomplete, sol: Incomplete, heur: Incomplete) -> Incomplete: ... - def trySol(self, solution: Incomplete, printreason: Incomplete = ..., completely: Incomplete = ..., checkbounds: Incomplete = ..., checkintegrality: Incomplete = ..., checklprows: Incomplete = ..., free: Incomplete = ...) -> Incomplete: ... - def updateBendersLowerbounds(self, lowerbounds: Incomplete, benders: Incomplete = ...) -> Incomplete: ... + def translateSubSol( + self, sub_model: Incomplete, sol: Incomplete, heur: Incomplete + ) -> Incomplete: ... + def trySol( + self, + solution: Incomplete, + printreason: Incomplete = ..., + completely: Incomplete = ..., + checkbounds: Incomplete = ..., + checkintegrality: Incomplete = ..., + checklprows: Incomplete = ..., + free: Incomplete = ..., + ) -> Incomplete: ... + def updateBendersLowerbounds( + self, lowerbounds: Incomplete, benders: Incomplete = ... + ) -> Incomplete: ... def updateNodeLowerbound(self, node: Incomplete, lb: Incomplete) -> Incomplete: ... - def updateVarPseudocost(self, var: Incomplete, valdelta: Incomplete, objdelta: Incomplete, weight: Incomplete) -> Incomplete: ... + def updateVarPseudocost( + self, + var: Incomplete, + valdelta: Incomplete, + objdelta: Incomplete, + weight: Incomplete, + ) -> Incomplete: ... def version(self) -> Incomplete: ... - def writeBestSol(self, filename: Incomplete = ..., write_zeros: Incomplete = ...) -> Incomplete: ... - def writeBestTransSol(self, filename: Incomplete = ..., write_zeros: Incomplete = ...) -> Incomplete: ... + def writeBestSol( + self, filename: Incomplete = ..., write_zeros: Incomplete = ... + ) -> Incomplete: ... + def writeBestTransSol( + self, filename: Incomplete = ..., write_zeros: Incomplete = ... + ) -> Incomplete: ... def writeLP(self, filename: Incomplete = ...) -> Incomplete: ... - def writeMIP(self, filename: Incomplete, genericnames: Incomplete = ..., origobj: Incomplete = ..., lazyconss: Incomplete = ...) -> Incomplete: ... + def writeMIP( + self, + filename: Incomplete, + genericnames: Incomplete = ..., + origobj: Incomplete = ..., + lazyconss: Incomplete = ..., + ) -> Incomplete: ... def writeName(self, var: Incomplete) -> Incomplete: ... - def writeParams(self, filename: Incomplete = ..., comments: Incomplete = ..., onlychanged: Incomplete = ..., verbose: Incomplete = ...) -> Incomplete: ... - def writeProblem(self, filename: Incomplete = ..., trans: Incomplete = ..., genericnames: Incomplete = ..., verbose: Incomplete = ...) -> Incomplete: ... - def writeSol(self, solution: Incomplete, filename: Incomplete = ..., write_zeros: Incomplete = ...) -> Incomplete: ... + def writeParams( + self, + filename: Incomplete = ..., + comments: Incomplete = ..., + onlychanged: Incomplete = ..., + verbose: Incomplete = ..., + ) -> Incomplete: ... + def writeProblem( + self, + filename: Incomplete = ..., + trans: Incomplete = ..., + genericnames: Incomplete = ..., + verbose: Incomplete = ..., + ) -> Incomplete: ... + def writeSol( + self, + solution: Incomplete, + filename: Incomplete = ..., + write_zeros: Incomplete = ..., + ) -> Incomplete: ... def writeStatistics(self, filename: Incomplete = ...) -> Incomplete: ... def writeStatisticsJson(self, filename: Incomplete = ...) -> Incomplete: ... - def writeTransSol(self, solution: Incomplete, filename: Incomplete = ..., write_zeros: Incomplete = ...) -> Incomplete: ... + def writeTransSol( + self, + solution: Incomplete, + filename: Incomplete = ..., + write_zeros: Incomplete = ..., + ) -> Incomplete: ... def __eq__(self, other: object) -> bool: ... def __ge__(self, other: object) -> bool: ... def __gt__(self, other: object) -> bool: ... @@ -1202,7 +1917,9 @@ class PowExpr(GenExpr): class Presol: model: Incomplete def __init__(self) -> None: ... - def presolexec(self, nrounds: Incomplete, presoltiming: Incomplete) -> Incomplete: ... + def presolexec( + self, nrounds: Incomplete, presoltiming: Incomplete + ) -> Incomplete: ... def presolexit(self) -> Incomplete: ... def presolexitpre(self) -> Incomplete: ... def presolfree(self) -> Incomplete: ... @@ -1238,8 +1955,16 @@ class Prop: def propinit(self) -> Incomplete: ... def propinitpre(self) -> Incomplete: ... def propinitsol(self) -> Incomplete: ... - def proppresol(self, nrounds: Incomplete, presoltiming: Incomplete, result_dict: Incomplete) -> Incomplete: ... - def propresprop(self, confvar: Incomplete, inferinfo: Incomplete, bdtype: Incomplete, relaxedbd: Incomplete) -> Incomplete: ... + def proppresol( + self, nrounds: Incomplete, presoltiming: Incomplete, result_dict: Incomplete + ) -> Incomplete: ... + def propresprop( + self, + confvar: Incomplete, + inferinfo: Incomplete, + bdtype: Incomplete, + relaxedbd: Incomplete, + ) -> Incomplete: ... @disjoint_base class Reader: @@ -1248,7 +1973,25 @@ class Reader: def __init__(self) -> None: ... def readerfree(self) -> Incomplete: ... def readerread(self, filename: Incomplete) -> Incomplete: ... - def readerwrite(self, file: Incomplete, name: Incomplete, transformed: Incomplete, objsense: Incomplete, objoffset: Incomplete, objscale: Incomplete, binvars: Incomplete, intvars: Incomplete, implvars: Incomplete, contvars: Incomplete, fixedvars: Incomplete, startnvars: Incomplete, conss: Incomplete, maxnconss: Incomplete, startnconss: Incomplete, genericnames: Incomplete) -> Incomplete: ... + def readerwrite( + self, + file: Incomplete, + name: Incomplete, + transformed: Incomplete, + objsense: Incomplete, + objoffset: Incomplete, + objscale: Incomplete, + binvars: Incomplete, + intvars: Incomplete, + implvars: Incomplete, + contvars: Incomplete, + fixedvars: Incomplete, + startnvars: Incomplete, + conss: Incomplete, + maxnconss: Incomplete, + startnconss: Incomplete, + genericnames: Incomplete, + ) -> Incomplete: ... @disjoint_base class Relax: From 69030d680b526086e237d02beeab8db7b8f5114b Mon Sep 17 00:00:00 2001 From: Jonathan Berthias Date: Sat, 3 Jan 2026 23:41:29 +0100 Subject: [PATCH 11/15] 'Resolve' MatrixExpr.sum issue --- src/pyscipopt/scip.pyi | 4 +++- stubs/allowlist | 1 - stubs/todo | 4 ++-- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/src/pyscipopt/scip.pyi b/src/pyscipopt/scip.pyi index ef61239f8..62ee2bc5f 100644 --- a/src/pyscipopt/scip.pyi +++ b/src/pyscipopt/scip.pyi @@ -508,7 +508,9 @@ class MatrixConstraint(numpy.ndarray): def isStickingAtNode(self) -> Incomplete: ... class MatrixExpr(numpy.ndarray): - def sum(self, *args, **kwargs): ... + def sum( # type: ignore[override] + self, axis: Incomplete = ..., keepdims: Incomplete = ..., **kwargs: Incomplete + ) -> Incomplete: ... def __add__(self, other): ... def __eq__(self, other: object) -> bool: ... def __ge__(self, other: object) -> MatrixExprCons: ... diff --git a/stubs/allowlist b/stubs/allowlist index 73a81d4d3..16b3ad843 100644 --- a/stubs/allowlist +++ b/stubs/allowlist @@ -1,5 +1,4 @@ .*.__reduce_cython__ .*.__setstate_cython__ pyscipopt.scip.__test__ -pyscipopt.scip.Statistics.* pyscipopt._version.__conditional_annotations__ diff --git a/stubs/todo b/stubs/todo index 2eb7be13d..2187481cc 100644 --- a/stubs/todo +++ b/stubs/todo @@ -1,3 +1,3 @@ -pyscipopt.MatrixExpr.sum pyscipopt.recipes.primal_dual_evolution.GapEventhdlr@14 -pyscipopt.scip.MatrixExpr.sum +pyscipopt.scip.Statistics.__init__ +pyscipopt.scip.Statistics.__match_args__ From 0d9e6e3f66620141515d6d5064446ed03110c4c1 Mon Sep 17 00:00:00 2001 From: Jonathan Berthias Date: Sat, 3 Jan 2026 23:59:15 +0100 Subject: [PATCH 12/15] Annotate everything with Incomplete --- .github/workflows/stubs.yml | 2 +- src/pyscipopt/scip.pyi | 272 ++++++++++++++++++------------------ 2 files changed, 137 insertions(+), 137 deletions(-) diff --git a/.github/workflows/stubs.yml b/.github/workflows/stubs.yml index 9fd0c3768..559f8d97b 100644 --- a/.github/workflows/stubs.yml +++ b/.github/workflows/stubs.yml @@ -65,7 +65,7 @@ jobs: args: "--version" - name: Lint type stubs - run: ruff check ${{ env.FILES }} --extend-select I,PYI + run: ruff check ${{ env.FILES }} --extend-select ANN,I,PYI,RUF100 - name: Format type stubs run: ruff format ${{ env.FILES }} diff --git a/src/pyscipopt/scip.pyi b/src/pyscipopt/scip.pyi index 62ee2bc5f..fa0e3cf76 100644 --- a/src/pyscipopt/scip.pyi +++ b/src/pyscipopt/scip.pyi @@ -119,13 +119,13 @@ class Column: def getUb(self) -> Incomplete: ... def getVar(self) -> Incomplete: ... def isIntegral(self) -> Incomplete: ... - def __eq__(self, other: object) -> bool: ... - def __ge__(self, other: object) -> bool: ... - def __gt__(self, other: object) -> bool: ... + def __eq__(self, other: Incomplete)-> Incomplete: ... + def __ge__(self, other: Incomplete)-> Incomplete: ... + def __gt__(self, other: Incomplete)-> Incomplete: ... def __hash__(self) -> int: ... - def __le__(self, other: object) -> bool: ... - def __lt__(self, other: object) -> bool: ... - def __ne__(self, other: object) -> bool: ... + def __le__(self, other: Incomplete)-> Incomplete: ... + def __lt__(self, other: Incomplete)-> Incomplete: ... + def __ne__(self, other: Incomplete)-> Incomplete: ... @disjoint_base class ColumnExact: @@ -233,7 +233,7 @@ class Conshdlr: @disjoint_base class Constant(GenExpr): number: Incomplete - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self, *args: Incomplete, **kwargs: Incomplete) -> None: ... @disjoint_base class Constraint: @@ -257,13 +257,13 @@ class Constraint: def isRemovable(self) -> Incomplete: ... def isSeparated(self) -> Incomplete: ... def isStickingAtNode(self) -> Incomplete: ... - def __eq__(self, other: object) -> bool: ... - def __ge__(self, other: object) -> bool: ... - def __gt__(self, other: object) -> bool: ... + def __eq__(self, other: Incomplete)-> Incomplete: ... + def __ge__(self, other: Incomplete)-> Incomplete: ... + def __gt__(self, other: Incomplete)-> Incomplete: ... def __hash__(self) -> int: ... - def __le__(self, other: object) -> bool: ... - def __lt__(self, other: object) -> bool: ... - def __ne__(self, other: object) -> bool: ... + def __le__(self, other: Incomplete)-> Incomplete: ... + def __lt__(self, other: Incomplete)-> Incomplete: ... + def __ne__(self, other: Incomplete)-> Incomplete: ... @disjoint_base class Cutsel: @@ -299,13 +299,13 @@ class Event: def getRow(self) -> Incomplete: ... def getType(self) -> Incomplete: ... def getVar(self) -> Incomplete: ... - def __eq__(self, other: object) -> bool: ... - def __ge__(self, other: object) -> bool: ... - def __gt__(self, other: object) -> bool: ... + def __eq__(self, other: Incomplete)-> Incomplete: ... + def __ge__(self, other: Incomplete)-> Incomplete: ... + def __gt__(self, other: Incomplete)-> Incomplete: ... def __hash__(self) -> int: ... - def __le__(self, other: object) -> bool: ... - def __lt__(self, other: object) -> bool: ... - def __ne__(self, other: object) -> bool: ... + def __le__(self, other: Incomplete)-> Incomplete: ... + def __lt__(self, other: Incomplete)-> Incomplete: ... + def __ne__(self, other: Incomplete)-> Incomplete: ... @disjoint_base class Eventhdlr: @@ -324,72 +324,72 @@ class Eventhdlr: @disjoint_base class Expr: terms: Incomplete - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self, *args: Incomplete, **kwargs: Incomplete) -> None: ... def degree(self) -> Incomplete: ... def normalize(self) -> Incomplete: ... - def __abs__(self): ... - def __add__(self, other): ... - def __eq__(self, other: object) -> bool: ... - def __ge__(self, other: object) -> bool: ... - def __getitem__(self, index): ... - def __gt__(self, other: object) -> bool: ... - def __iadd__(self, other): ... - def __iter__(self): ... - def __le__(self, other: object) -> bool: ... - def __lt__(self, other: object) -> bool: ... - def __mul__(self, other): ... - def __ne__(self, other: object) -> bool: ... - def __neg__(self): ... - def __next__(self): ... + def __abs__(self) -> Incomplete: ... + def __add__(self, other: Incomplete) -> Incomplete: ... + def __eq__(self, other: Incomplete)-> Incomplete: ... + def __ge__(self, other: Incomplete)-> Incomplete: ... + def __getitem__(self, index: Incomplete) -> Incomplete: ... + def __gt__(self, other: Incomplete)-> Incomplete: ... + def __iadd__(self, other: Incomplete) -> Incomplete: ... # noqa: PYI034 + def __iter__(self) -> Incomplete: ... + def __le__(self, other: Incomplete)-> Incomplete: ... + def __lt__(self, other: Incomplete)-> Incomplete: ... + def __mul__(self, other: Incomplete) -> Incomplete: ... + def __ne__(self, other: Incomplete)-> Incomplete: ... + def __neg__(self) -> Incomplete: ... + def __next__(self) -> Incomplete: ... def __pow__(self, other: Incomplete, mod: Incomplete = ...) -> Incomplete: ... - def __radd__(self, other): ... - def __rmul__(self, other): ... - def __rpow__(self, other): ... - def __rsub__(self, other): ... - def __rtruediv__(self, other): ... - def __sub__(self, other): ... - def __truediv__(self, other): ... + def __radd__(self, other: Incomplete) -> Incomplete: ... + def __rmul__(self, other: Incomplete) -> Incomplete: ... + def __rpow__(self, other: Incomplete) -> Incomplete: ... + def __rsub__(self, other: Incomplete) -> Incomplete: ... + def __rtruediv__(self, other: Incomplete) -> Incomplete: ... + def __sub__(self, other: Incomplete) -> Incomplete: ... + def __truediv__(self, other: Incomplete) -> Incomplete: ... @disjoint_base class ExprCons: _lhs: Incomplete _rhs: Incomplete expr: Incomplete - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self, *args: Incomplete, **kwargs: Incomplete) -> None: ... def normalize(self) -> Incomplete: ... - def __bool__(self) -> bool: ... - def __eq__(self, other: object) -> bool: ... - def __ge__(self, other: object) -> bool: ... - def __gt__(self, other: object) -> bool: ... - def __le__(self, other: object) -> bool: ... - def __lt__(self, other: object) -> bool: ... - def __ne__(self, other: object) -> bool: ... + def __bool__(self)-> Incomplete: ... + def __eq__(self, other: Incomplete)-> Incomplete: ... + def __ge__(self, other: Incomplete)-> Incomplete: ... + def __gt__(self, other: Incomplete)-> Incomplete: ... + def __le__(self, other: Incomplete)-> Incomplete: ... + def __lt__(self, other: Incomplete)-> Incomplete: ... + def __ne__(self, other: Incomplete)-> Incomplete: ... @disjoint_base class GenExpr: _op: Incomplete children: Incomplete - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self, *args: Incomplete, **kwargs: Incomplete) -> None: ... def degree(self) -> Incomplete: ... def getOp(self) -> Incomplete: ... - def __abs__(self): ... - def __add__(self, other): ... - def __eq__(self, other: object) -> bool: ... - def __ge__(self, other: object) -> bool: ... - def __gt__(self, other: object) -> bool: ... - def __le__(self, other: object) -> bool: ... - def __lt__(self, other: object) -> bool: ... - def __mul__(self, other): ... - def __ne__(self, other: object) -> bool: ... - def __neg__(self): ... + def __abs__(self) -> Incomplete: ... + def __add__(self, other: Incomplete) -> Incomplete: ... + def __eq__(self, other: Incomplete)-> Incomplete: ... + def __ge__(self, other: Incomplete)-> Incomplete: ... + def __gt__(self, other: Incomplete)-> Incomplete: ... + def __le__(self, other: Incomplete)-> Incomplete: ... + def __lt__(self, other: Incomplete)-> Incomplete: ... + def __mul__(self, other: Incomplete) -> Incomplete: ... + def __ne__(self, other: Incomplete)-> Incomplete: ... + def __neg__(self) -> Incomplete: ... def __pow__(self, other: Incomplete, mod: Incomplete = ...) -> Incomplete: ... - def __radd__(self, other): ... - def __rmul__(self, other): ... - def __rpow__(self, other): ... - def __rsub__(self, other): ... - def __rtruediv__(self, other): ... - def __sub__(self, other): ... - def __truediv__(self, other): ... + def __radd__(self, other: Incomplete) -> Incomplete: ... + def __rmul__(self, other: Incomplete) -> Incomplete: ... + def __rpow__(self, other: Incomplete) -> Incomplete: ... + def __rsub__(self, other: Incomplete) -> Incomplete: ... + def __rtruediv__(self, other: Incomplete) -> Incomplete: ... + def __sub__(self, other: Incomplete) -> Incomplete: ... + def __truediv__(self, other: Incomplete) -> Incomplete: ... @disjoint_base class Heur: @@ -427,7 +427,7 @@ class IISfinder: @disjoint_base class LP: name: Incomplete - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self, *args: Incomplete, **kwargs: Incomplete) -> None: ... def addCol( self, entries: Incomplete, @@ -511,25 +511,25 @@ class MatrixExpr(numpy.ndarray): def sum( # type: ignore[override] self, axis: Incomplete = ..., keepdims: Incomplete = ..., **kwargs: Incomplete ) -> Incomplete: ... - def __add__(self, other): ... - def __eq__(self, other: object) -> bool: ... - def __ge__(self, other: object) -> MatrixExprCons: ... - def __iadd__(self, other): ... - def __le__(self, other: object) -> MatrixExprCons: ... + def __add__(self, other: Incomplete) -> Incomplete: ... + def __eq__(self, other: Incomplete)-> Incomplete: ... + def __ge__(self, other: Incomplete) -> MatrixExprCons: ... + def __iadd__(self, other: Incomplete) -> Incomplete: ... # noqa: PYI034 + def __le__(self, other: Incomplete) -> MatrixExprCons: ... def __matmul__(self, other: Incomplete) -> Incomplete: ... - def __mul__(self, other): ... - def __pow__(self, other): ... - def __radd__(self, other): ... - def __rmul__(self, other): ... - def __rsub__(self, other): ... - def __rtruediv__(self, other): ... - def __sub__(self, other): ... - def __truediv__(self, other): ... + def __mul__(self, other: Incomplete) -> Incomplete: ... + def __pow__(self, other: Incomplete) -> Incomplete: ... # type: ignore[override] + def __radd__(self, other: Incomplete) -> Incomplete: ... + def __rmul__(self, other: Incomplete) -> Incomplete: ... + def __rsub__(self, other: Incomplete) -> Incomplete: ... + def __rtruediv__(self, other: Incomplete) -> Incomplete: ... + def __sub__(self, other: Incomplete) -> Incomplete: ... + def __truediv__(self, other: Incomplete) -> Incomplete: ... class MatrixExprCons(numpy.ndarray): - def __eq__(self, other: object) -> bool: ... - def __ge__(self, other: object) -> MatrixExprCons: ... - def __le__(self, other: object) -> MatrixExprCons: ... + def __eq__(self, other: Incomplete)-> Incomplete: ... + def __ge__(self, other: Incomplete) -> MatrixExprCons: ... + def __le__(self, other: Incomplete) -> MatrixExprCons: ... class MatrixGenExpr(MatrixExpr): ... @@ -553,7 +553,7 @@ class MatrixVariable(MatrixExpr): class Model: _freescip: Incomplete data: Incomplete - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self, *args: Incomplete, **kwargs: Incomplete) -> None: ... def _createConsGenNonlinear( self, cons: Incomplete, **kwargs: Incomplete ) -> Incomplete: ... @@ -1572,13 +1572,13 @@ class Model: filename: Incomplete = ..., write_zeros: Incomplete = ..., ) -> Incomplete: ... - def __eq__(self, other: object) -> bool: ... - def __ge__(self, other: object) -> bool: ... - def __gt__(self, other: object) -> bool: ... + def __eq__(self, other: Incomplete)-> Incomplete: ... + def __ge__(self, other: Incomplete)-> Incomplete: ... + def __gt__(self, other: Incomplete)-> Incomplete: ... def __hash__(self) -> int: ... - def __le__(self, other: object) -> bool: ... - def __lt__(self, other: object) -> bool: ... - def __ne__(self, other: object) -> bool: ... + def __le__(self, other: Incomplete)-> Incomplete: ... + def __lt__(self, other: Incomplete)-> Incomplete: ... + def __ne__(self, other: Incomplete)-> Incomplete: ... @disjoint_base class NLRow: @@ -1590,13 +1590,13 @@ class NLRow: def getLhs(self) -> Incomplete: ... def getLinearTerms(self) -> Incomplete: ... def getRhs(self) -> Incomplete: ... - def __eq__(self, other: object) -> bool: ... - def __ge__(self, other: object) -> bool: ... - def __gt__(self, other: object) -> bool: ... + def __eq__(self, other: Incomplete)-> Incomplete: ... + def __ge__(self, other: Incomplete)-> Incomplete: ... + def __gt__(self, other: Incomplete)-> Incomplete: ... def __hash__(self) -> int: ... - def __le__(self, other: object) -> bool: ... - def __lt__(self, other: object) -> bool: ... - def __ne__(self, other: object) -> bool: ... + def __le__(self, other: Incomplete)-> Incomplete: ... + def __lt__(self, other: Incomplete)-> Incomplete: ... + def __ne__(self, other: Incomplete)-> Incomplete: ... @disjoint_base class Node: @@ -1616,13 +1616,13 @@ class Node: def getType(self) -> Incomplete: ... def isActive(self) -> Incomplete: ... def isPropagatedAgain(self) -> Incomplete: ... - def __eq__(self, other: object) -> bool: ... - def __ge__(self, other: object) -> bool: ... - def __gt__(self, other: object) -> bool: ... + def __eq__(self, other: Incomplete)-> Incomplete: ... + def __ge__(self, other: Incomplete)-> Incomplete: ... + def __gt__(self, other: Incomplete)-> Incomplete: ... def __hash__(self) -> int: ... - def __le__(self, other: object) -> bool: ... - def __lt__(self, other: object) -> bool: ... - def __ne__(self, other: object) -> bool: ... + def __le__(self, other: Incomplete)-> Incomplete: ... + def __lt__(self, other: Incomplete)-> Incomplete: ... + def __ne__(self, other: Incomplete)-> Incomplete: ... @disjoint_base class Nodesel: @@ -1913,7 +1913,7 @@ class PY_SCIP_STATUS: @disjoint_base class PowExpr(GenExpr): expo: Incomplete - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self, *args: Incomplete, **kwargs: Incomplete) -> None: ... @disjoint_base class Presol: @@ -1943,7 +1943,7 @@ class Pricer: @disjoint_base class ProdExpr(GenExpr): constant: Incomplete - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self, *args: Incomplete, **kwargs: Incomplete) -> None: ... @disjoint_base class Prop: @@ -2032,13 +2032,13 @@ class Row: def isLocal(self) -> Incomplete: ... def isModifiable(self) -> Incomplete: ... def isRemovable(self) -> Incomplete: ... - def __eq__(self, other: object) -> bool: ... - def __ge__(self, other: object) -> bool: ... - def __gt__(self, other: object) -> bool: ... + def __eq__(self, other: Incomplete)-> Incomplete: ... + def __ge__(self, other: Incomplete)-> Incomplete: ... + def __gt__(self, other: Incomplete)-> Incomplete: ... def __hash__(self) -> int: ... - def __le__(self, other: object) -> bool: ... - def __lt__(self, other: object) -> bool: ... - def __ne__(self, other: object) -> bool: ... + def __le__(self, other: Incomplete)-> Incomplete: ... + def __lt__(self, other: Incomplete)-> Incomplete: ... + def __ne__(self, other: Incomplete)-> Incomplete: ... @disjoint_base class RowExact: @@ -2061,15 +2061,15 @@ class Sepa: @disjoint_base class Solution: data: Incomplete - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self, *args: Incomplete, **kwargs: Incomplete) -> None: ... def _checkStage(self, method: Incomplete) -> Incomplete: ... def _evaluate(self, term: Incomplete) -> Incomplete: ... def getOrigin(self) -> Incomplete: ... def retransform(self) -> Incomplete: ... def translate(self, target: Incomplete) -> Incomplete: ... - def __delitem__(self, other) -> None: ... - def __getitem__(self, index): ... - def __setitem__(self, index, object) -> None: ... + def __delitem__(self, other: Incomplete) -> None: ... + def __getitem__(self, index: Incomplete) -> Incomplete: ... + def __setitem__(self, index: Incomplete, object: Incomplete) -> None: ... @dataclass class Statistics: @@ -2090,64 +2090,64 @@ class Statistics: gap: float | None = None primal_dual_integral: float | None = None @property - def n_binary_vars(self): ... + def n_binary_vars(self) -> Incomplete: ... @property - def n_conss(self): ... + def n_conss(self) -> Incomplete: ... @property - def n_continuous_vars(self): ... + def n_continuous_vars(self) -> Incomplete: ... @property - def n_implicit_integer_vars(self): ... + def n_implicit_integer_vars(self) -> Incomplete: ... @property - def n_integer_vars(self): ... + def n_integer_vars(self) -> Incomplete: ... @property - def n_maximal_cons(self): ... + def n_maximal_cons(self) -> Incomplete: ... @property - def n_presolved_binary_vars(self): ... + def n_presolved_binary_vars(self) -> Incomplete: ... @property - def n_presolved_conss(self): ... + def n_presolved_conss(self) -> Incomplete: ... @property - def n_presolved_continuous_vars(self): ... + def n_presolved_continuous_vars(self) -> Incomplete: ... @property - def n_presolved_implicit_integer_vars(self): ... + def n_presolved_implicit_integer_vars(self) -> Incomplete: ... @property - def n_presolved_integer_vars(self): ... + def n_presolved_integer_vars(self) -> Incomplete: ... @property - def n_presolved_maximal_cons(self): ... + def n_presolved_maximal_cons(self) -> Incomplete: ... @property - def n_presolved_vars(self): ... + def n_presolved_vars(self) -> Incomplete: ... @property - def n_vars(self): ... + def n_vars(self) -> Incomplete: ... @disjoint_base class SumExpr(GenExpr): coefs: Incomplete constant: Incomplete - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self, *args: Incomplete, **kwargs: Incomplete) -> None: ... class Term: hashval: Incomplete ptrtuple: Incomplete vartuple: Incomplete def __init__(self, *args: Incomplete) -> None: ... - def __add__(self, other): ... - def __eq__(self, other: object) -> bool: ... - def __getitem__(self, index): ... + def __add__(self, other: Incomplete) -> Incomplete: ... + def __eq__(self, other: Incomplete)-> Incomplete: ... + def __getitem__(self, index: Incomplete) -> Incomplete: ... def __hash__(self) -> int: ... def __len__(self) -> int: ... class UnaryExpr(GenExpr): - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self, *args: Incomplete, **kwargs: Incomplete) -> None: ... @disjoint_base class VarExpr(GenExpr): var: Incomplete - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self, *args: Incomplete, **kwargs: Incomplete) -> None: ... @disjoint_base class Variable(Expr): data: Incomplete name: Incomplete - def __init__(self, *args, **kwargs) -> None: ... + def __init__(self, *args: Incomplete, **kwargs: Incomplete) -> None: ... def getAvgSol(self) -> Incomplete: ... def getCol(self) -> Incomplete: ... def getImplType(self) -> Incomplete: ... From b5e565e5695701be20975342d65357083bb60f62 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Dion=C3=ADsio?= <57299939+Joao-Dionisio@users.noreply.github.com> Date: Mon, 5 Jan 2026 11:51:43 +0100 Subject: [PATCH 13/15] fix iis and test (#1146) --- CHANGELOG.md | 1 + src/pyscipopt/iisfinder.pxi | 1 + tests/test_iis.py | 4 +--- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 5a94d66b0..55ffa776c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,7 @@ ### Fixed - all fundamental callbacks now raise an error if not implemented - Fixed the type of MatrixExpr.sum(axis=...) result from MatrixVariable to MatrixExpr. +- Updated IIS result in PyiisfinderExec() ### Changed - changed default value of enablepricing flag to True ### Removed diff --git a/src/pyscipopt/iisfinder.pxi b/src/pyscipopt/iisfinder.pxi index e06ac83e3..390ee5c4e 100644 --- a/src/pyscipopt/iisfinder.pxi +++ b/src/pyscipopt/iisfinder.pxi @@ -33,4 +33,5 @@ cdef SCIP_RETCODE PyiisfinderExec (SCIP_IIS* iis, SCIP_IISFINDER* iisfinder, SCI PyIIS.iis._iis = iis result_dict = PyIIS.iisfinderexec() assert isinstance(result_dict, dict), "iisfinderexec() must return a dictionary." + result[0] = result_dict.get("result", result[0]) return SCIP_OKAY \ No newline at end of file diff --git a/tests/test_iis.py b/tests/test_iis.py index 2538c44ba..c48326509 100644 --- a/tests/test_iis.py +++ b/tests/test_iis.py @@ -76,9 +76,7 @@ def test_iisGreddyMakeIrreducible(): m.includeIISfinder(my_iis, "", "", priority=10000) iis = m.generateIIS() - with pytest.raises(AssertionError): - assert not iis.isSubscipIrreducible() # this should not fail - + assert not iis.isSubscipIrreducible() assert iis.isSubscipInfeasible() iis.greedyMakeIrreducible() From 9ed4159e7621726c84274f4086b01a16b1d33b5f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Dion=C3=ADsio?= <57299939+Joao-Dionisio@users.noreply.github.com> Date: Mon, 5 Jan 2026 12:21:47 +0100 Subject: [PATCH 14/15] Automating the generation of type stubs (#1142) * first attempt at script * wrapped SCIPaddClique * remove clique --- CHANGELOG.md | 2 + scripts/generate_stubs.py | 807 ++++++++++++++++++++++++++++++++++++++ src/pyscipopt/scip.pyi | 10 +- 3 files changed, 817 insertions(+), 2 deletions(-) create mode 100755 scripts/generate_stubs.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 55ffa776c..36d8322dd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,8 @@ ## Unreleased ### Added +- Added automated script for generating type stubs +- Wrapped SCIPaddClique - Speed up MatrixExpr.sum(axis=...) via quicksum ### Fixed - all fundamental callbacks now raise an error if not implemented diff --git a/scripts/generate_stubs.py b/scripts/generate_stubs.py new file mode 100755 index 000000000..52acbaed2 --- /dev/null +++ b/scripts/generate_stubs.py @@ -0,0 +1,807 @@ +#!/usr/bin/env python3 +""" +Automatic stub generator for PySCIPOpt. + +This script parses .pxi and .pxd files and generates .pyi stub files automatically. +It extracts class definitions, methods, attributes, and module-level functions. + +Usage: + python scripts/generate_stubs.py + +The generated stub will be written to src/pyscipopt/scip.pyi +""" + +import re +import os +from pathlib import Path +from dataclasses import dataclass, field +from typing import Optional +from collections import OrderedDict + + +@dataclass +class ClassInfo: + """Holds information about a class.""" + name: str + parent: Optional[str] = None + attributes: list = field(default_factory=list) # list of (name, type_hint) + methods: list = field(default_factory=list) # list of method names + static_methods: set = field(default_factory=set) # set of static method names + class_vars: list = field(default_factory=list) # list of (name, type_hint) + has_hash: bool = False + has_eq: bool = False + is_dataclass: bool = False + dataclass_fields: list = field(default_factory=list) # list of (name, type, default) + + +@dataclass +class ModuleInfo: + """Holds information about the module.""" + classes: OrderedDict = field(default_factory=OrderedDict) + functions: list = field(default_factory=list) + module_vars: list = field(default_factory=list) + + +class StubGenerator: + """Generates Python stub files from Cython .pxi and .pxd files.""" + + # Special methods that need specific type hints + COMPARISON_METHODS = { + '__eq__': 'def __eq__(self, other: object) -> bool: ...', + '__ne__': 'def __ne__(self, other: object) -> bool: ...', + '__lt__': 'def __lt__(self, other: object) -> bool: ...', + '__le__': 'def __le__(self, other: object) -> bool: ...', + '__gt__': 'def __gt__(self, other: object) -> bool: ...', + '__ge__': 'def __ge__(self, other: object) -> bool: ...', + } + + SPECIAL_METHODS = { + '__hash__': 'def __hash__(self) -> int: ...', + '__len__': 'def __len__(self) -> int: ...', + '__bool__': 'def __bool__(self) -> bool: ...', + '__init__': 'def __init__(self, *args, **kwargs) -> None: ...', + '__repr__': 'def __repr__(self) -> str: ...', + '__str__': 'def __str__(self) -> str: ...', + '__delitem__': 'def __delitem__(self, other) -> None: ...', + '__setitem__': 'def __setitem__(self, index, object) -> None: ...', + } + + # Methods that should NOT appear in stubs (internal Cython methods) + EXCLUDED_METHODS = { + '__cinit__', '__dealloc__', '__reduce__', '__reduce_cython__', + '__setstate_cython__', '__pyx_vtable__', '__repr__', '__str__', + } + + # Methods that should be expanded to comparison methods + RICHCMP_EXPANSION = { + '__richcmp__': ['__eq__', '__ne__', '__lt__', '__le__', '__gt__', '__ge__'], + } + + # Methods with specific type hints (no *args, **kwargs) + TYPED_METHODS = { + '__getitem__': 'def __getitem__(self, index): ...', + '__iter__': 'def __iter__(self): ...', + '__next__': 'def __next__(self): ...', + '__add__': 'def __add__(self, other): ...', + '__radd__': 'def __radd__(self, other): ...', + '__sub__': 'def __sub__(self, other): ...', + '__rsub__': 'def __rsub__(self, other): ...', + '__mul__': 'def __mul__(self, other): ...', + '__rmul__': 'def __rmul__(self, other): ...', + '__truediv__': 'def __truediv__(self, other): ...', + '__rtruediv__': 'def __rtruediv__(self, other): ...', + '__pow__': 'def __pow__(self, other): ...', + '__rpow__': 'def __rpow__(self, other): ...', + '__neg__': 'def __neg__(self): ...', + '__abs__': 'def __abs__(self): ...', + '__iadd__': 'def __iadd__(self, other): ...', + '__isub__': 'def __isub__(self, other): ...', + '__imul__': 'def __imul__(self, other): ...', + } + + def __init__(self, src_dir: Path): + self.src_dir = src_dir + self.module_info = ModuleInfo() + + # Classes that inherit from numpy.ndarray need special handling + self.numpy_classes = {'MatrixExpr', 'MatrixConstraint'} + + # Known parent classes mapping (from class name to parent in stubs) + self.inheritance_map = { + 'Variable': 'Expr', + 'Constant': 'GenExpr', + 'VarExpr': 'GenExpr', + 'PowExpr': 'GenExpr', + 'UnaryExpr': 'GenExpr', + 'SumExpr': 'GenExpr', + 'ProdExpr': 'GenExpr', + 'MatrixExpr': 'numpy.ndarray', + 'MatrixConstraint': 'numpy.ndarray', + 'MatrixExprCons': 'numpy.ndarray', + 'MatrixGenExpr': 'MatrixExpr', + 'MatrixVariable': 'MatrixExpr', + } + + def parse_pxi_file(self, filepath: Path) -> None: + """Parse a .pxi file and extract class/function definitions.""" + with open(filepath, 'r', encoding='utf-8') as f: + content = f.read() + + self._parse_content(content, filepath) + + def parse_pxd_file(self, filepath: Path) -> None: + """Parse a .pxd file and extract public attributes.""" + with open(filepath, 'r', encoding='utf-8') as f: + content = f.read() + + # Find class definitions and their public attributes + class_pattern = re.compile( + r'^cdef\s+class\s+(\w+)(?:\s*\((\w+)\))?:\s*$', + re.MULTILINE + ) + + attr_pattern = re.compile( + r'^\s+cdef\s+public\s+(?:object\s+)?(\w+)\s*$', + re.MULTILINE + ) + + lines = content.split('\n') + current_class = None + + for i, line in enumerate(lines): + # Check for class definition + class_match = class_pattern.match(line) + if class_match: + class_name = class_match.group(1) + parent = class_match.group(2) + current_class = class_name + + if class_name not in self.module_info.classes: + self.module_info.classes[class_name] = ClassInfo( + name=class_name, + parent=parent + ) + continue + + # Check for public attribute + if current_class and 'cdef public' in line: + # Extract attribute name + match = re.search(r'cdef\s+public\s+(?:\w+\s+)?(\w+)\s*$', line.strip()) + if match: + attr_name = match.group(1) + if current_class in self.module_info.classes: + cls_info = self.module_info.classes[current_class] + if (attr_name, 'Incomplete') not in cls_info.attributes: + cls_info.attributes.append((attr_name, 'Incomplete')) + + # Detect end of class (unindented line that's not empty or comment) + if current_class and line and not line.startswith(' ') and not line.startswith('\t'): + if not line.startswith('#') and not line.startswith('cdef class'): + current_class = None + + def _parse_content(self, content: str, filepath: Path) -> None: + """Parse content from a .pxi file.""" + lines = content.split('\n') + + # Stack of (class_name, base_indent) for nested class tracking + # Only track top-level classes (indent 0) for stub generation + class_stack = [] + in_property = False + property_name = None + + def get_current_class(): + """Get the current class if we're directly in a top-level class. + + Returns None if: + - We're not in any class + - We're in a nested class (not the top-level class) + """ + if not class_stack: + return None + # Only return a class if we're directly in a top-level (indent 0) class + # If the latest class on the stack is not at indent 0, we're in a nested class + latest_class, latest_indent = class_stack[-1] + if latest_indent == 0: + return latest_class + return None + + i = 0 + while i < len(lines): + line = lines[i] + stripped = line.strip() + + # Skip empty lines and comments + if not stripped or stripped.startswith('#'): + i += 1 + continue + + # Calculate indentation (handle tabs as 4 spaces) + raw_indent = 0 + for ch in line: + if ch == ' ': + raw_indent += 1 + elif ch == '\t': + raw_indent += 4 + else: + break + indent = raw_indent + + # Pop classes from stack when we see a line at or below their base indent + while class_stack and indent <= class_stack[-1][1]: + class_stack.pop() + + # Check for class definition + class_match = re.match( + r'^(?:cdef\s+)?class\s+(\w+)(?:\s*\(([^)]*)\))?:\s*$', + stripped + ) + if class_match: + class_name = class_match.group(1) + parent = class_match.group(2) + + # Clean up parent (remove Cython types) + if parent: + parent = parent.strip() + # Skip internal Cython parent classes + if parent in ('object',): + parent = None + + # Push to class stack + class_stack.append((class_name, indent)) + + # Only add top-level classes (indent 0) to module info + if indent == 0: + if class_name not in self.module_info.classes: + self.module_info.classes[class_name] = ClassInfo( + name=class_name, + parent=self.inheritance_map.get(class_name, parent) + ) + i += 1 + continue + + current_class = get_current_class() + + # Check for property definition + property_match = re.match(r'^property\s+(\w+)\s*:', stripped) + if property_match and current_class: + property_name = property_match.group(1) + in_property = True + i += 1 + continue + + # Check for property __get__ (indicates a readable attribute) + if in_property and 'def __get__(self)' in stripped: + if current_class and property_name: + cls_info = self.module_info.classes.get(current_class) + if cls_info and (property_name, 'Incomplete') not in cls_info.attributes: + cls_info.attributes.append((property_name, 'Incomplete')) + in_property = False + property_name = None + i += 1 + continue + + # Check for public attribute in class body + if current_class and 'cdef public' in stripped: + match = re.search(r'cdef\s+public\s+(?:\w+\s+)?(\w+)\s*$', stripped) + if match: + attr_name = match.group(1) + cls_info = self.module_info.classes.get(current_class) + if cls_info and (attr_name, 'Incomplete') not in cls_info.attributes: + cls_info.attributes.append((attr_name, 'Incomplete')) + i += 1 + continue + + # Check for __slots__ definition + if current_class and '__slots__' in stripped: + slots_match = re.search(r"__slots__\s*=\s*\(([^)]+)\)", stripped) + if slots_match: + slots_str = slots_match.group(1) + # Parse slot names + slot_names = re.findall(r"['\"](\w+)['\"]", slots_str) + cls_info = self.module_info.classes.get(current_class) + if cls_info: + for slot_name in slot_names: + if (slot_name, 'Incomplete') not in cls_info.attributes: + cls_info.attributes.append((slot_name, 'Incomplete')) + i += 1 + continue + + # Check for class variable assignment (for enum-like classes) + if current_class: + cls_info = self.module_info.classes.get(current_class) + if cls_info: + # Handle multi-assignment lines like: exp, log, sqrt = 'exp', 'log', 'sqrt' + # Only for Op class (special case for operator definitions) + if current_class == 'Op' and indent == 4: + multi_match = re.match(r'^(\w+(?:\s*,\s*\w+)+)\s*=\s*(.+)$', stripped) + if multi_match: + var_names = [v.strip() for v in multi_match.group(1).split(',')] + var_values = multi_match.group(2).strip() + + # Determine type from first value + if var_values.startswith('"') or var_values.startswith("'"): + type_hint = 'str' + elif var_values.isdigit() or 'SCIP_' in var_values: + type_hint = 'int' + else: + type_hint = 'str' + + for var_name in var_names: + if not var_name.startswith('_') and var_name not in ('self',): + if (var_name, type_hint) not in cls_info.class_vars: + cls_info.class_vars.append((var_name, type_hint)) + i += 1 + continue + + # Match pattern like: ATTRNAME = SCIP_VALUE or ATTRNAME = VALUE + var_match = re.match(r'^(\w+)\s*=\s*(.+)$', stripped) + if var_match: + var_name = var_match.group(1) + var_value = var_match.group(2).strip() + + # Skip private variables, special cases, and method assignments + if not var_name.startswith('_') and var_name not in ('self',): + # Determine type from value pattern + if 'SCIP_' in var_value or var_value.isdigit(): + type_hint = 'int' + elif var_value.startswith('"') or var_value.startswith("'"): + type_hint = 'str' + else: + type_hint = 'int' # default for enum-like + + # For UPPERCASE names, use ClassVar + if var_name.isupper(): + if (var_name, type_hint) not in cls_info.class_vars: + cls_info.class_vars.append((var_name, type_hint)) + # For lowercase class variables (like in Op class), only add if: + # - Class has no methods yet (we're at class-level, not in a method) + # - The class is in a known list of classes with class vars + elif current_class == 'Op' and indent == 4: + if (var_name, type_hint) not in cls_info.class_vars: + cls_info.class_vars.append((var_name, type_hint)) + i += 1 + continue + + # Check for decorators (look at previous non-empty lines) + is_property = False + is_setter = False + is_staticmethod = False + if stripped.startswith('def ') and i > 0: + # Look back for decorators + for j in range(i - 1, max(0, i - 5), -1): + prev_line = lines[j].strip() + if prev_line == '@property': + is_property = True + elif '.setter' in prev_line or '.deleter' in prev_line: + is_setter = True + elif prev_line == '@staticmethod': + is_staticmethod = True + elif prev_line and not prev_line.startswith('#') and not prev_line.startswith('@'): + break + + # Check for method definition (handle multi-line signatures) + # First, check if this line starts a def/cpdef + method_start_match = re.match( + r'^(?:cpdef|def)\s+(\w+)\s*\(', + stripped + ) + if method_start_match: + method_name = method_start_match.group(1) + + # Skip setters (they don't need separate stubs) + if is_setter: + i += 1 + continue + + # Skip nested functions (defined inside methods, at high indentation) + # Methods should be at indent 4 for top-level class methods + if current_class and indent > 4: + # This is likely a nested function, skip it + i += 1 + continue + + # Skip excluded methods (internal Cython methods) + if method_name in self.EXCLUDED_METHODS: + i += 1 + continue + + if current_class: + cls_info = self.module_info.classes.get(current_class) + if cls_info: + if is_property: + # Add as attribute instead of method + if (method_name, 'Incomplete') not in cls_info.attributes: + cls_info.attributes.append((method_name, 'Incomplete')) + elif method_name == '__richcmp__': + # Expand __richcmp__ to individual comparison methods + for cmp_method in self.RICHCMP_EXPANSION['__richcmp__']: + if cmp_method not in cls_info.methods: + cls_info.methods.append(cmp_method) + elif method_name not in cls_info.methods: + cls_info.methods.append(method_name) + + # Track static methods + if is_staticmethod: + cls_info.static_methods.add(method_name) + + # Track special methods + if method_name == '__hash__': + cls_info.has_hash = True + elif method_name == '__eq__': + cls_info.has_eq = True + else: + # Module-level function (must be at indent 0) + if indent == 0 and method_name not in self.module_info.functions: + self.module_info.functions.append(method_name) + + i += 1 + continue + + # Check for module-level variable + if not current_class and indent == 0: + var_match = re.match(r'^(\w+)\s*=\s*', stripped) + if var_match: + var_name = var_match.group(1) + if not var_name.startswith('_') and var_name not in ('include',): + if var_name not in [v[0] for v in self.module_info.module_vars]: + self.module_info.module_vars.append((var_name, 'Incomplete')) + + i += 1 + + def _detect_dataclass(self, content: str) -> dict: + """Detect @dataclass decorated classes and their fields.""" + dataclasses = {} + + # Find @dataclass decorated classes + pattern = re.compile( + r'@dataclass\s*\n\s*class\s+(\w+)(?:\s*\([^)]*\))?\s*:\s*\n((?:\s+.+\n)*)', + re.MULTILINE + ) + + for match in pattern.finditer(content): + class_name = match.group(1) + body = match.group(2) + + fields = [] + for line in body.split('\n'): + # Match field: type = default or field: type + field_match = re.match(r'\s+(\w+)\s*:\s*(\w+)(?:\s*=\s*(.+))?', line) + if field_match: + fname = field_match.group(1) + ftype = field_match.group(2) + fdefault = field_match.group(3) + fields.append((fname, ftype, fdefault)) + + dataclasses[class_name] = fields + + return dataclasses + + def generate_stub(self) -> str: + """Generate the complete stub file content.""" + lines = [] + + # Header imports + lines.append('from dataclasses import dataclass') + lines.append('from typing import ClassVar') + lines.append('') + lines.append('import numpy') + lines.append('from _typeshed import Incomplete') + lines.append('') + + # Module-level variables and functions (sorted alphabetically) + # Merge variables and functions into a single sorted list + all_module_items = [] + + for var_name, type_hint in self.module_info.module_vars: + all_module_items.append((var_name, 'var', type_hint)) + + for func_name in self.module_info.functions: + all_module_items.append((func_name, 'func', None)) + + # Sort by name + all_module_items.sort(key=lambda x: x[0]) + + for name, kind, type_hint in all_module_items: + if kind == 'var': + lines.append(f'{name}: {type_hint}') + else: + lines.append(f'{name}: Incomplete') + + if all_module_items: + lines.append('') + + # Classes (sorted alphabetically) + sorted_classes = sorted( + self.module_info.classes.values(), + key=lambda c: c.name + ) + + for cls_info in sorted_classes: + # Skip internal classes + if cls_info.name.startswith('_') and cls_info.name != '_VarArray': + continue + + lines.extend(self._generate_class_stub(cls_info)) + lines.append('') + + return '\n'.join(lines) + + def _generate_class_stub(self, cls_info: ClassInfo) -> list: + """Generate stub for a single class.""" + lines = [] + + # Handle dataclass + if cls_info.is_dataclass: + lines.append('@dataclass') + + # Class declaration + if cls_info.parent: + lines.append(f'class {cls_info.name}({cls_info.parent}):') + else: + lines.append(f'class {cls_info.name}:') + + # Dataclass fields + if cls_info.dataclass_fields: + for fname, ftype, fdefault in cls_info.dataclass_fields: + if fdefault: + lines.append(f' {fname}: {ftype} = {fdefault}') + else: + lines.append(f' {fname}: {ftype}') + return lines + + # Class variables (for enum-like classes) + sorted_class_vars = sorted(cls_info.class_vars, key=lambda x: x[0]) + for var_name, type_hint in sorted_class_vars: + lines.append(f' {var_name}: ClassVar[{type_hint}] = ...') + + # Instance attributes + sorted_attrs = sorted(cls_info.attributes, key=lambda x: x[0]) + for attr_name, type_hint in sorted_attrs: + lines.append(f' {attr_name}: {type_hint}') + + # Methods - separate regular methods and special methods + regular_methods = [] + special_methods = [] + comparison_methods = [] + + for method in cls_info.methods: + if method in self.COMPARISON_METHODS: + comparison_methods.append(method) + elif method.startswith('__') and method.endswith('__'): + special_methods.append(method) + else: + regular_methods.append(method) + + # Check if this class inherits from numpy.ndarray or MatrixExpr (don't auto-add __init__) + is_numpy_subclass = cls_info.parent and ('ndarray' in cls_info.parent or 'Matrix' in cls_info.parent) + + # Specific classes that shouldn't get __init__ auto-added + skip_init_classes = {'Op'} + + # If class has both __hash__ and __eq__, add all comparison methods + if cls_info.has_hash and cls_info.has_eq: + for cmp_method in self.COMPARISON_METHODS: + if cmp_method not in comparison_methods and cmp_method not in special_methods: + comparison_methods.append(cmp_method) + + # Output __init__ first if present or needs to be added (not for numpy subclasses or specific classes) + if '__init__' in special_methods: + lines.append(f' {self.SPECIAL_METHODS["__init__"]}') + special_methods.remove('__init__') + elif '__init__' not in cls_info.methods and not is_numpy_subclass and not cls_info.is_dataclass and cls_info.name not in skip_init_classes: + lines.append(f' {self.SPECIAL_METHODS["__init__"]}') + + # Sort and output regular methods + for method in sorted(regular_methods): + if method in cls_info.static_methods: + lines.append(' @staticmethod') + lines.append(f' def {method}(*args, **kwargs): ...') + else: + lines.append(f' def {method}(self, *args, **kwargs): ...') + + # Combine special methods and comparison methods, sort alphabetically + all_special = [] + for method in special_methods: + if method in self.SPECIAL_METHODS: + all_special.append((method, self.SPECIAL_METHODS[method])) + elif method in self.TYPED_METHODS: + all_special.append((method, self.TYPED_METHODS[method])) + else: + all_special.append((method, f'def {method}(self, *args, **kwargs): ...')) + + for method in comparison_methods: + all_special.append((method, self.COMPARISON_METHODS[method])) + + # Sort and output all special methods alphabetically + for method, stub in sorted(all_special, key=lambda x: x[0]): + lines.append(f' {stub}') + + # If class is empty, add pass or ellipsis + if len(lines) == 1: + lines.append(' ...') + + return lines + + def run(self) -> str: + """Run the stub generator on all relevant files.""" + pxi_files = list(self.src_dir.glob('*.pxi')) + pxd_files = list(self.src_dir.glob('*.pxd')) + + # Parse .pxd files first for attribute declarations + for pxd_file in pxd_files: + print(f'Parsing {pxd_file.name}...') + self.parse_pxd_file(pxd_file) + + # Parse .pxi files for implementations + for pxi_file in pxi_files: + print(f'Parsing {pxi_file.name}...') + self.parse_pxi_file(pxi_file) + + # Handle special cases + self._apply_special_cases() + + # Generate the stub + return self.generate_stub() + + def _apply_special_cases(self) -> None: + """Apply special cases and known patterns.""" + # Add 'name' attribute to classes that commonly have it + name_classes = { + 'Variable', 'Constraint', 'Row', 'NLRow', 'Event', + 'Benders', 'Benderscut', 'Conshdlr', 'Heur', 'Sepa', + 'Reader', 'Relax', 'Eventhdlr' + } + + for class_name in name_classes: + if class_name in self.module_info.classes: + cls_info = self.module_info.classes[class_name] + if ('name', 'Incomplete') not in cls_info.attributes: + cls_info.attributes.append(('name', 'Incomplete')) + + # Handle LP class special case (readonly name) + if 'LP' in self.module_info.classes: + cls_info = self.module_info.classes['LP'] + if ('name', 'Incomplete') not in cls_info.attributes: + cls_info.attributes.append(('name', 'Incomplete')) + + # Handle Statistics as dataclass + if 'Statistics' in self.module_info.classes: + cls_info = self.module_info.classes['Statistics'] + cls_info.is_dataclass = True + cls_info.dataclass_fields = [ + ('status', 'str', None), + ('total_time', 'float', None), + ('solving_time', 'float', None), + ('presolving_time', 'float', None), + ('reading_time', 'float', None), + ('copying_time', 'float', None), + ('problem_name', 'str', None), + ('presolved_problem_name', 'str', None), + ('n_runs', 'int', 'None'), + ('n_nodes', 'int', 'None'), + ('n_solutions_found', 'int', '-1'), + ('first_solution', 'float', 'None'), + ('primal_bound', 'float', 'None'), + ('dual_bound', 'float', 'None'), + ('gap', 'float', 'None'), + ] + + # Add/update known module-level variables with correct types + known_vars = { + 'CONST': 'Term', + 'EventNames': 'dict', + 'MAJOR': 'int', + 'MINOR': 'int', + 'Operator': 'Op', + 'PATCH': 'int', + 'StageNames': 'dict', + '_SCIP_BOUNDTYPE_TO_STRING': 'dict', + 'str_conversion': 'Incomplete', + } + + # Remove PY_SCIP_CALL from functions if it exists (it's also a callable) + if 'PY_SCIP_CALL' in self.module_info.functions: + self.module_info.functions.remove('PY_SCIP_CALL') + known_vars['PY_SCIP_CALL'] = 'Incomplete' + + # Update existing or add new + updated_vars = [] + seen = set() + for var_name, type_hint in self.module_info.module_vars: + if var_name in known_vars: + updated_vars.append((var_name, known_vars[var_name])) + seen.add(var_name) + else: + updated_vars.append((var_name, type_hint)) + seen.add(var_name) + + # Add any known vars that weren't in the list + for var_name, type_hint in known_vars.items(): + if var_name not in seen: + updated_vars.append((var_name, type_hint)) + + self.module_info.module_vars = updated_vars + + +def main(): + """Main entry point.""" + import argparse + + parser = argparse.ArgumentParser( + description='Generate Python stub files (.pyi) from PySCIPOpt Cython sources.', + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=''' +Examples: + python scripts/generate_stubs.py # Generate and write stubs + python scripts/generate_stubs.py --check # Check if stubs are up-to-date + python scripts/generate_stubs.py --dry-run # Show what would be generated +''' + ) + parser.add_argument( + '--check', action='store_true', + help='Check if the stub file is up-to-date (exits with 1 if not)' + ) + parser.add_argument( + '--dry-run', action='store_true', + help='Print the generated stubs to stdout instead of writing to file' + ) + parser.add_argument( + '-q', '--quiet', action='store_true', + help='Suppress progress output' + ) + args = parser.parse_args() + + # Find the source directory + script_dir = Path(__file__).parent + project_root = script_dir.parent + src_dir = project_root / 'src' / 'pyscipopt' + + if not src_dir.exists(): + print(f'Error: Source directory not found: {src_dir}') + return 1 + + if not args.quiet: + print(f'Generating stubs from {src_dir}...') + + generator = StubGenerator(src_dir) + stub_content = generator.run() + + output_path = src_dir / 'scip.pyi' + + if args.dry_run: + print(stub_content) + return 0 + + if args.check: + # Compare with existing file + if output_path.exists(): + with open(output_path, 'r', encoding='utf-8') as f: + existing_content = f.read() + if existing_content == stub_content: + if not args.quiet: + print('Stub file is up-to-date.') + return 0 + else: + print(f'Stub file {output_path} is out of date.') + print('Run without --check to regenerate.') + return 1 + else: + print(f'Stub file {output_path} does not exist.') + return 1 + + # Write the stub file + with open(output_path, 'w', encoding='utf-8') as f: + f.write(stub_content) + + if not args.quiet: + print(f'Stub file written to {output_path}') + print(f'\nSummary:') + print(f' Classes: {len(generator.module_info.classes)}') + print(f' Functions: {len(generator.module_info.functions)}') + print(f' Module variables: {len(generator.module_info.module_vars)}') + + return 0 + + +if __name__ == '__main__': + exit(main()) diff --git a/src/pyscipopt/scip.pyi b/src/pyscipopt/scip.pyi index c89521f00..8637c6a11 100644 --- a/src/pyscipopt/scip.pyi +++ b/src/pyscipopt/scip.pyi @@ -194,6 +194,7 @@ class DomainChanges: class Event: data: Incomplete + name: Incomplete def __init__(self, *args, **kwargs) -> None: ... def _getEventNames(self, *args, **kwargs): ... def getName(self, *args, **kwargs): ... @@ -397,7 +398,8 @@ class MatrixExprCons(numpy.ndarray): def __ge__(self, other: object) -> MatrixExprCons: ... def __le__(self, other: object) -> MatrixExprCons: ... -class MatrixGenExpr(MatrixExpr): ... +class MatrixGenExpr(MatrixExpr): + ... class MatrixVariable(MatrixExpr): def getAvgSol(self, *args, **kwargs): ... @@ -1286,7 +1288,6 @@ class Solution: def getOrigin(self, *args, **kwargs): ... def retransform(self, *args, **kwargs): ... def translate(self, *args, **kwargs): ... - def __delitem__(self, other) -> None: ... def __getitem__(self, index): ... def __setitem__(self, index, object) -> None: ... @@ -1349,9 +1350,14 @@ class Term: def __init__(self, *args, **kwargs) -> None: ... def __add__(self, other): ... def __eq__(self, other: object) -> bool: ... + def __ge__(self, other: object) -> bool: ... def __getitem__(self, index): ... + def __gt__(self, other: object) -> bool: ... def __hash__(self) -> int: ... + def __le__(self, other: object) -> bool: ... def __len__(self) -> int: ... + def __lt__(self, other: object) -> bool: ... + def __ne__(self, other: object) -> bool: ... class UnaryExpr(GenExpr): def __init__(self, *args, **kwargs) -> None: ... From b4d9ea5b3231a0abf1ce6aae3568b583e7670dfe Mon Sep 17 00:00:00 2001 From: Jonathan Berthias Date: Mon, 5 Jan 2026 21:36:06 +0100 Subject: [PATCH 15/15] Update CHANGELOG.md --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 36d8322dd..cec5a1cdc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,7 +3,7 @@ ## Unreleased ### Added - Added automated script for generating type stubs -- Wrapped SCIPaddClique +- Include parameter names in type stubs - Speed up MatrixExpr.sum(axis=...) via quicksum ### Fixed - all fundamental callbacks now raise an error if not implemented