PySCIPOpt 5.2.1__tar.gz → 5.3.0__tar.gz

{pyscipopt-5.2.1 → pyscipopt-5.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: PySCIPOpt
-Version: 5.2.1
+Version: 5.3.0
 Summary: Python interface and modeling environment for SCIP
 Home-page: https://github.com/SCIP-Interfaces/PySCIPOpt
 Author: Zuse Institute Berlin
@@ -17,6 +17,8 @@ Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: author
+Dynamic: home-page
 
 PySCIPOpt
 =========

{pyscipopt-5.2.1 → pyscipopt-5.3.0}/PySCIPOpt.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: PySCIPOpt
-Version: 5.2.1
+Version: 5.3.0
 Summary: Python interface and modeling environment for SCIP
 Home-page: https://github.com/SCIP-Interfaces/PySCIPOpt
 Author: Zuse Institute Berlin
@@ -17,6 +17,8 @@ Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: author
+Dynamic: home-page
 
 PySCIPOpt
 =========

{pyscipopt-5.2.1 → pyscipopt-5.3.0}/PySCIPOpt.egg-info/SOURCES.txt

@@ -34,6 +34,7 @@ src/pyscipopt/recipes/__init__.py
 src/pyscipopt/recipes/infeasibilities.py
 src/pyscipopt/recipes/nonlinear.py
 src/pyscipopt/recipes/piecewise.py
+src/pyscipopt/recipes/primal_dual_evolution.py
 tests/test_alldiff.py
 tests/test_benders.py
 tests/test_bipartite.py
@@ -56,6 +57,7 @@ tests/test_memory.py
 tests/test_model.py
 tests/test_nlrow.py
 tests/test_nodesel.py
+tests/test_nogil.py
 tests/test_nonlinear.py
 tests/test_pricer.py
 tests/test_quadcons.py
@@ -65,11 +67,13 @@ tests/test_reader.py
 tests/test_recipe_infeasibilities.py
 tests/test_recipe_nonlinear.py
 tests/test_recipe_piecewise.py
+tests/test_recipe_primal_dual_evolution.py
 tests/test_relax.py
 tests/test_reopt.py
 tests/test_short.py
 tests/test_solution.py
 tests/test_strong_branching.py
+tests/test_sub_sol.py
 tests/test_tree.py
 tests/test_tsp.py
 tests/test_vars.py

{pyscipopt-5.2.1 → pyscipopt-5.3.0}/pyproject.toml

@@ -45,7 +45,7 @@ manylinux-x86_64-image = "manylinux_2_28"
 skip="pp* cp36* cp37* *musllinux*"
 before-all = [
     "(apt-get update && apt-get install --yes wget) || yum install -y wget zlib libgfortran || brew install wget",
-    "wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.5.0/libscip-linux.zip -O scip.zip",
+    "wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.7.0/libscip-linux.zip -O scip.zip",
     "unzip scip.zip",
     "mv scip_install scip"
     ]
@@ -58,10 +58,10 @@ before-all = '''
 #!/bin/bash
 brew install wget zlib gcc
 if [[ $CIBW_ARCHS == *"arm"* ]]; then
-    wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.5.0/libscip-macos-arm.zip -O scip.zip
+    wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.7.0/libscip-macos-arm.zip -O scip.zip
     export MACOSX_DEPLOYMENT_TARGET=14.0
 else
-    wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.5.0/libscip-macos.zip -O scip.zip
+    wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.7.0/libscip-macos-intel.zip -O scip.zip
     export MACOSX_DEPLOYMENT_TARGET=13.0
 fi
 unzip scip.zip
@@ -87,7 +87,7 @@ repair-wheel-command = '''
 skip="pp* cp36* cp37*"
 before-all = [
     "choco install 7zip wget",
-    "wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.5.0/libscip-windows.zip -O scip.zip",
+    "wget https://github.com/scipopt/scipoptsuite-deploy/releases/download/v0.7.0/libscip-windows.zip -O scip.zip",
     "\"C:\\Program Files\\7-Zip\\7z.exe\" x \"scip.zip\" -o\"scip-test\"",
     "mv .\\scip-test\\scip_install .\\test",
     "mv .\\test .\\scip"

{pyscipopt-5.2.1 → pyscipopt-5.3.0}/setup.py

@@ -109,7 +109,7 @@ with open("README.md") as f:
 
 setup(
     name="PySCIPOpt",
-    version="5.2.1",
+    version="5.3.0",
     description="Python interface and modeling environment for SCIP",
     long_description=long_description,
     long_description_content_type="text/markdown",

{pyscipopt-5.2.1 → pyscipopt-5.3.0}/src/pyscipopt/__init__.py

@@ -46,3 +46,4 @@ from pyscipopt.scip      import PY_SCIP_LPSOLSTAT    as SCIP_LPSOLSTAT
 from pyscipopt.scip      import PY_SCIP_BRANCHDIR    as SCIP_BRANCHDIR
 from pyscipopt.scip      import PY_SCIP_BENDERSENFOTYPE as SCIP_BENDERSENFOTYPE
 from pyscipopt.scip      import PY_SCIP_ROWORIGINTYPE as SCIP_ROWORIGINTYPE
+from pyscipopt.scip      import PY_SCIP_SOLORIGIN as SCIP_SOLORIGIN

pyscipopt-5.3.0/src/pyscipopt/_version.py

@@ -0,0 +1 @@
+__version__ = '5.3.0'

{pyscipopt-5.2.1 → pyscipopt-5.3.0}/src/pyscipopt/benders.pxi

@@ -175,8 +175,8 @@ cdef SCIP_RETCODE PyBendersSolvesub (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL
 cdef SCIP_RETCODE PyBendersPostsolve (SCIP* scip, SCIP_BENDERS* benders, SCIP_SOL* sol,
         SCIP_BENDERSENFOTYPE type, int* mergecands, int npriomergecands, int nmergecands, SCIP_Bool checkint,
         SCIP_Bool infeasible, SCIP_Bool* merged) noexcept with gil:
-    cdef SCIP_BENDERSDATA* bendersdata
-    bendersdata = SCIPbendersGetData(benders)
+    cdef SCIP_BENDERSDATA* bendersdata = SCIPbendersGetData(benders)
+    cdef int i
     PyBenders = <Benders>bendersdata
     if sol == NULL:
         solution = None

{pyscipopt-5.2.1 → pyscipopt-5.3.0}/src/pyscipopt/conshdlr.pxi

@@ -168,48 +168,54 @@ cdef SCIP_RETCODE PyConsFree (SCIP* scip, SCIP_CONSHDLR* conshdlr) noexcept with
     return SCIP_OKAY
 
 cdef SCIP_RETCODE PyConsInit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
+    cdef int i
     PyConshdlr = getPyConshdlr(conshdlr)
-    cdef constraints = []
+    constraints = []
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     PyConshdlr.consinit(constraints)
     return SCIP_OKAY
 
 cdef SCIP_RETCODE PyConsExit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
+    cdef int i
     PyConshdlr = getPyConshdlr(conshdlr)
-    cdef constraints = []
+    constraints = []
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     PyConshdlr.consexit(constraints)
     return SCIP_OKAY
 
 cdef SCIP_RETCODE PyConsInitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
+    cdef int i
     PyConshdlr = getPyConshdlr(conshdlr)
-    cdef constraints = []
+    constraints = []
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     PyConshdlr.consinitpre(constraints)
     return SCIP_OKAY
 
 cdef SCIP_RETCODE PyConsExitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
+    cdef int i
     PyConshdlr = getPyConshdlr(conshdlr)
-    cdef constraints = []
+    constraints = []
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     PyConshdlr.consexitpre(constraints)
     return SCIP_OKAY
 
 cdef SCIP_RETCODE PyConsInitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
+    cdef int i
     PyConshdlr = getPyConshdlr(conshdlr)
-    cdef constraints = []
+    constraints = []
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     PyConshdlr.consinitsol(constraints)
     return SCIP_OKAY
 
 cdef SCIP_RETCODE PyConsExitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool restart) noexcept with gil:
+    cdef int i
     PyConshdlr = getPyConshdlr(conshdlr)
-    cdef constraints = []
+    constraints = []
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     PyConshdlr.consexitsol(constraints, restart)
@@ -244,8 +250,9 @@ cdef SCIP_RETCODE PyConsTrans (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* s
     return SCIP_OKAY
 
 cdef SCIP_RETCODE PyConsInitlp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool* infeasible) noexcept with gil:
+    cdef int i
     PyConshdlr = getPyConshdlr(conshdlr)
-    cdef constraints = []
+    constraints = []
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     result_dict = PyConshdlr.consinitlp(constraints)
@@ -253,8 +260,9 @@ cdef SCIP_RETCODE PyConsInitlp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS**
     return SCIP_OKAY
 
 cdef SCIP_RETCODE PyConsSepalp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_RESULT* result) noexcept with gil:
+    cdef int i
     PyConshdlr = getPyConshdlr(conshdlr)
-    cdef constraints = []
+    constraints = []
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     result_dict = PyConshdlr.conssepalp(constraints, nusefulconss)
@@ -263,8 +271,9 @@ cdef SCIP_RETCODE PyConsSepalp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS**
 
 cdef SCIP_RETCODE PyConsSepasol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss,
                                  SCIP_SOL* sol, SCIP_RESULT* result) noexcept with gil:
+    cdef int i
     PyConshdlr = getPyConshdlr(conshdlr)
-    cdef constraints = []
+    constraints = []
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     solution = Solution.create(scip, sol)
@@ -274,8 +283,9 @@ cdef SCIP_RETCODE PyConsSepasol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS*
 
 cdef SCIP_RETCODE PyConsEnfolp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss,
                                 SCIP_Bool solinfeasible, SCIP_RESULT* result) noexcept with gil:
+    cdef int i
     PyConshdlr = getPyConshdlr(conshdlr)
-    cdef constraints = []
+    constraints = []
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     result_dict = PyConshdlr.consenfolp(constraints, nusefulconss, solinfeasible)
@@ -283,8 +293,9 @@ cdef SCIP_RETCODE PyConsEnfolp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS**
     return SCIP_OKAY
 
 cdef SCIP_RETCODE PyConsEnforelax (SCIP* scip, SCIP_SOL* sol, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_Bool solinfeasible, SCIP_RESULT* result) noexcept with gil:
+    cdef int i
     PyConshdlr = getPyConshdlr(conshdlr)
-    cdef constraints = []
+    constraints = []
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     solution = Solution.create(scip, sol)
@@ -294,8 +305,9 @@ cdef SCIP_RETCODE PyConsEnforelax (SCIP* scip, SCIP_SOL* sol, SCIP_CONSHDLR* con
 
 cdef SCIP_RETCODE PyConsEnfops (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss,
                                 SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT* result) noexcept with gil:
+    cdef int i
     PyConshdlr = getPyConshdlr(conshdlr)
-    cdef constraints = []
+    constraints = []
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     result_dict = PyConshdlr.consenfops(constraints, nusefulconss, solinfeasible, objinfeasible)
@@ -304,8 +316,9 @@ cdef SCIP_RETCODE PyConsEnfops (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS**
 
 cdef SCIP_RETCODE PyConsCheck (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_SOL* sol, SCIP_Bool checkintegrality,
                                SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT* result) noexcept with gil:
+    cdef int i
     PyConshdlr = getPyConshdlr(conshdlr)
-    cdef constraints = []
+    constraints = []
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     solution = Solution.create(scip, sol)
@@ -315,8 +328,9 @@ cdef SCIP_RETCODE PyConsCheck (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS**
 
 cdef SCIP_RETCODE PyConsProp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, int nmarkedconss,
                               SCIP_PROPTIMING proptiming, SCIP_RESULT* result) noexcept with gil:
+    cdef int i
     PyConshdlr = getPyConshdlr(conshdlr)
-    cdef constraints = []
+    constraints = []
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     result_dict = PyConshdlr.consprop(constraints, nusefulconss, nmarkedconss, proptiming)
@@ -328,8 +342,9 @@ cdef SCIP_RETCODE PyConsPresol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS**
                                 int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides,
                                 int* nfixedvars, int* naggrvars, int* nchgvartypes, int* nchgbds, int* naddholes,
                                 int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result) noexcept with gil:
+    cdef int i
     PyConshdlr = getPyConshdlr(conshdlr)
-    cdef constraints = []
+    constraints = []
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     # dictionary for input/output parameters
@@ -401,8 +416,9 @@ cdef SCIP_RETCODE PyConsDisable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS*
     return SCIP_OKAY
 
 cdef SCIP_RETCODE PyConsDelvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
+    cdef int i
     PyConshdlr = getPyConshdlr(conshdlr)
-    cdef constraints = []
+    constraints = []
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     PyConshdlr.consdelvars(constraints)

{pyscipopt-5.2.1 → pyscipopt-5.3.0}/src/pyscipopt/cutsel.pxi

@@ -72,9 +72,10 @@ cdef SCIP_RETCODE PyCutselExitsol (SCIP* scip, SCIP_CUTSEL* cutsel) noexcept wit
 cdef SCIP_RETCODE PyCutselSelect (SCIP* scip, SCIP_CUTSEL* cutsel, SCIP_ROW** cuts, int ncuts,
                                   SCIP_ROW** forcedcuts, int nforcedcuts, SCIP_Bool root, int maxnselectedcuts,
                                   int* nselectedcuts, SCIP_RESULT* result) noexcept with gil:
-  cdef SCIP_CUTSELDATA* cutseldata
+  cdef SCIP_CUTSELDATA* cutseldata = SCIPcutselGetData(cutsel)
   cdef SCIP_ROW* scip_row
-  cutseldata = SCIPcutselGetData(cutsel)
+  cdef int i
+
   PyCutsel = <Cutsel>cutseldata
 
   # translate cuts to python

{pyscipopt-5.2.1 → pyscipopt-5.3.0}/src/pyscipopt/lp.pxi

@@ -63,19 +63,14 @@ cdef class LP:
         lb      -- lower bound (default 0.0)
         ub      -- upper bound (default infinity)
         """
-        nnonz = len(entries)
-
+        cdef int nnonz = len(entries)
         cdef SCIP_Real* c_coefs  = <SCIP_Real*> malloc(nnonz * sizeof(SCIP_Real))
         cdef int* c_inds = <int*>malloc(nnonz * sizeof(int))
-        cdef SCIP_Real c_obj
-        cdef SCIP_Real c_lb
-        cdef SCIP_Real c_ub
-        cdef int c_beg
-
-        c_obj = obj
-        c_lb = lb
-        c_ub = ub if ub != None else self.infinity()
-        c_beg = 0
+        cdef SCIP_Real c_obj = obj
+        cdef SCIP_Real c_lb = lb
+        cdef SCIP_Real c_ub = ub if ub != None else self.infinity()
+        cdef int c_beg = 0
+        cdef int i
 
         for i,entry in enumerate(entries):
             c_inds[i] = entry[0]
@@ -95,17 +90,15 @@ cdef class LP:
         lbs   -- lower bounds (default 0.0)
         ubs   -- upper bounds (default infinity)
         """
-
-        ncols = len(entrieslist)
-        nnonz = sum(len(entries) for entries in entrieslist)
-
+        cdef int ncols = len(entrieslist)
         cdef SCIP_Real* c_objs   = <SCIP_Real*> malloc(ncols * sizeof(SCIP_Real))
         cdef SCIP_Real* c_lbs    = <SCIP_Real*> malloc(ncols * sizeof(SCIP_Real))
         cdef SCIP_Real* c_ubs    = <SCIP_Real*> malloc(ncols * sizeof(SCIP_Real))
         cdef SCIP_Real* c_coefs
         cdef int* c_inds
         cdef int* c_beg
-
+        cdef int nnonz = sum(len(entries) for entries in entrieslist)
+        cdef int i
 
         if nnonz > 0:
             c_coefs  = <SCIP_Real*> malloc(nnonz * sizeof(SCIP_Real))
@@ -158,18 +151,13 @@ cdef class LP:
         lhs     -- left-hand side of the row (default 0.0)
         rhs     -- right-hand side of the row (default infinity)
         """
-        beg = 0
-        nnonz = len(entries)
-
+        cdef int nnonz = len(entries)
         cdef SCIP_Real* c_coefs  = <SCIP_Real*> malloc(nnonz * sizeof(SCIP_Real))
         cdef int* c_inds = <int*>malloc(nnonz * sizeof(int))
-        cdef SCIP_Real c_lhs
-        cdef SCIP_Real c_rhs
-        cdef int c_beg
-
-        c_lhs = lhs
-        c_rhs = rhs if rhs != None else self.infinity()
-        c_beg = 0
+        cdef SCIP_Real c_lhs = lhs
+        cdef SCIP_Real c_rhs = rhs if rhs != None else self.infinity()
+        cdef int c_beg = 0
+        cdef int i
 
         for i,entry in enumerate(entries):
             c_inds[i] = entry[0]
@@ -188,16 +176,16 @@ cdef class LP:
         lhss        -- left-hand side of the row (default 0.0)
         rhss        -- right-hand side of the row (default infinity)
         """
-        nrows = len(entrieslist)
-        nnonz = sum(len(entries) for entries in entrieslist)
-
+        cdef int nrows = len(entrieslist)
         cdef SCIP_Real* c_lhss  = <SCIP_Real*> malloc(nrows * sizeof(SCIP_Real))
         cdef SCIP_Real* c_rhss  = <SCIP_Real*> malloc(nrows * sizeof(SCIP_Real))
+        cdef int* c_beg  = <int*>malloc(nrows * sizeof(int))
+        cdef int nnonz = sum(len(entries) for entries in entrieslist)
         cdef SCIP_Real* c_coefs = <SCIP_Real*> malloc(nnonz * sizeof(SCIP_Real))
         cdef int* c_inds = <int*>malloc(nnonz * sizeof(int))
-        cdef int* c_beg  = <int*>malloc(nrows * sizeof(int))
+        cdef int tmp = 0
+        cdef int i
 
-        tmp = 0
         for i,entries in enumerate(entrieslist):
             c_lhss[i] = lhss[i] if lhss != None else 0.0
             c_rhss[i] = rhss[i] if rhss != None else self.infinity()
@@ -232,6 +220,8 @@ cdef class LP:
         firstcol -- first column (default 0)
         lastcol  -- last column (default ncols - 1)
         """
+        cdef int i
+
         lastcol = lastcol if lastcol != None else self.ncols() - 1
 
         if firstcol > lastcol:
@@ -261,6 +251,8 @@ cdef class LP:
         firstrow -- first row (default 0)
         lastrow  -- last row (default nrows - 1)
         """
+        cdef int i
+
         lastrow = lastrow if lastrow != None else self.nrows() - 1
 
         if firstrow > lastrow:
@@ -290,8 +282,9 @@ cdef class LP:
         col -- column to change
         obj -- new objective coefficient
         """
-        cdef int c_col = col
         cdef SCIP_Real c_obj = obj
+        cdef int c_col = col
+
         PY_SCIP_CALL(SCIPlpiChgObj(self.lpi, 1, &c_col, &c_obj))
 
     def chgCoef(self, row, col, newval):
@@ -312,9 +305,10 @@ cdef class LP:
         lb  -- new lower bound
         ub  -- new upper bound
         """
-        cdef int c_col = col
         cdef SCIP_Real c_lb = lb
         cdef SCIP_Real c_ub = ub
+        cdef int c_col = col
+
         PY_SCIP_CALL(SCIPlpiChgBounds(self.lpi, 1, &c_col, &c_lb, &c_ub))
 
     def chgSide(self, row, lhs, rhs):
@@ -325,9 +319,10 @@ cdef class LP:
         lhs -- new left-hand side
         rhs -- new right-hand side
         """
-        cdef int c_row = row
         cdef SCIP_Real c_lhs = lhs
         cdef SCIP_Real c_rhs = rhs
+        cdef int c_row = row
+
         PY_SCIP_CALL(SCIPlpiChgSides(self.lpi, 1, &c_row, &c_lhs, &c_rhs))
 
     def clear(self):
@@ -337,13 +332,17 @@ cdef class LP:
     def nrows(self):
         """Returns the number of rows."""
         cdef int nrows
+
         PY_SCIP_CALL(SCIPlpiGetNRows(self.lpi, &nrows))
+
         return nrows
 
     def ncols(self):
         """Returns the number of columns."""
         cdef int ncols
+
         PY_SCIP_CALL(SCIPlpiGetNCols(self.lpi, &ncols))
+
         return ncols
 
     def solve(self, dual=True):
@@ -359,12 +358,15 @@ cdef class LP:
 
         cdef SCIP_Real objval
         PY_SCIP_CALL(SCIPlpiGetObjval(self.lpi, &objval))
+
         return objval
 
     def getPrimal(self):
         """Returns the primal solution of the last LP solve."""
-        ncols = self.ncols()
+        cdef int ncols = self.ncols()
         cdef SCIP_Real* c_primalsol = <SCIP_Real*> malloc(ncols * sizeof(SCIP_Real))
+        cdef int i
+
         PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, c_primalsol, NULL, NULL, NULL))
         primalsol = [0.0] * ncols
         for i in range(ncols):
@@ -379,8 +381,10 @@ cdef class LP:
 
     def getDual(self):
         """Returns the dual solution of the last LP solve."""
-        nrows = self.nrows()
+        cdef int nrows = self.nrows()
         cdef SCIP_Real* c_dualsol = <SCIP_Real*> malloc(nrows * sizeof(SCIP_Real))
+        cdef int i
+
         PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, NULL, c_dualsol, NULL, NULL))
         dualsol = [0.0] * nrows
         for i in range(nrows):
@@ -395,10 +399,16 @@ cdef class LP:
 
     def getPrimalRay(self):
         """Returns a primal ray if possible, None otherwise."""
+        cdef int ncols
+        cdef SCIP_Real* c_ray
+        cdef int i
+
         if not SCIPlpiHasPrimalRay(self.lpi):
             return None
+
         ncols = self.ncols()
-        cdef SCIP_Real* c_ray  = <SCIP_Real*> malloc(ncols * sizeof(SCIP_Real))
+        c_ray = <SCIP_Real*> malloc(ncols * sizeof(SCIP_Real))
+
         PY_SCIP_CALL(SCIPlpiGetPrimalRay(self.lpi, c_ray))
         ray = [0.0] * ncols
         for i in range(ncols):
@@ -409,10 +419,16 @@ cdef class LP:
 
     def getDualRay(self):
         """Returns a dual ray if possible, None otherwise."""
+        cdef int nrows
+        cdef SCIP_Real* c_ray
+        cdef int i
+
         if not SCIPlpiHasDualRay(self.lpi):
             return None
+
         nrows = self.nrows()
-        cdef SCIP_Real* c_ray  = <SCIP_Real*> malloc(nrows * sizeof(SCIP_Real))
+        c_ray = <SCIP_Real*> malloc(nrows * sizeof(SCIP_Real))
+
         PY_SCIP_CALL(SCIPlpiGetDualfarkas(self.lpi, c_ray))
         ray = [0.0] * nrows
         for i in range(nrows):
@@ -424,14 +440,17 @@ cdef class LP:
     def getNIterations(self):
         """Returns the number of LP iterations of the last LP solve."""
         cdef int niters
+
         PY_SCIP_CALL(SCIPlpiGetIterations(self.lpi, &niters))
+
         return niters
 
     def getRedcost(self):
         """Returns the reduced cost vector of the last LP solve."""
-        ncols = self.ncols()
-
+        cdef int ncols = self.ncols()
         cdef SCIP_Real* c_redcost = <SCIP_Real*> malloc(ncols * sizeof(SCIP_Real))
+        cdef int i
+
         PY_SCIP_CALL(SCIPlpiGetSol(self.lpi, NULL, NULL, NULL, NULL, c_redcost))
 
         redcost = []
@@ -439,12 +458,14 @@ cdef class LP:
             redcost[i].append(c_redcost[i])
 
         free(c_redcost)
+
         return redcost
 
     def getBasisInds(self):
         """Returns the indices of the basic columns and rows; index i >= 0 corresponds to column i, index i < 0 to row -i-1"""
-        nrows = self.nrows()
-        cdef int* c_binds  = <int*> malloc(nrows * sizeof(int))
+        cdef int nrows = self.nrows()
+        cdef int* c_binds = <int*> malloc(nrows * sizeof(int))
+        cdef int i
 
         PY_SCIP_CALL(SCIPlpiGetBasisInd(self.lpi, c_binds))
 
@@ -453,4 +474,5 @@ cdef class LP:
             binds.append(c_binds[i])
 
         free(c_binds)
+
         return binds

{pyscipopt-5.2.1 → pyscipopt-5.3.0}/src/pyscipopt/reader.pxi

@@ -45,9 +45,10 @@ cdef SCIP_RETCODE PyReaderWrite (SCIP* scip, SCIP_READER* reader, FILE* file,
                                  SCIP_VAR** fixedvars, int nfixedvars, int startnvars,
                                  SCIP_CONS** conss, int nconss, int maxnconss, int startnconss,
                                  SCIP_Bool genericnames, SCIP_RESULT* result) noexcept with gil:
-    cdef SCIP_READERDATA* readerdata
-    readerdata = SCIPreaderGetData(reader)
+    cdef SCIP_READERDATA* readerdata = SCIPreaderGetData(reader)
     cdef int fd = fileno(file)
+    cdef int i
+
     PyFile = os.fdopen(fd, "w", closefd=False)
     PyName = name.decode('utf-8')
     PyBinVars = [Variable.create(vars[i]) for i in range(nbinvars)]
@@ -61,4 +62,5 @@ cdef SCIP_RETCODE PyReaderWrite (SCIP* scip, SCIP_READER* reader, FILE* file,
                                        PyBinVars, PyIntVars, PyImplVars, PyContVars, PyFixedVars, startnvars,
                                        PyConss, maxnconss, startnconss, genericnames)
     result[0] = result_dict.get("result", <SCIP_RESULT>result[0])
+
     return SCIP_OKAY

pyscipopt-5.3.0/src/pyscipopt/recipes/primal_dual_evolution.py

@@ -0,0 +1,46 @@
+from pyscipopt import Model, Eventhdlr, SCIP_EVENTTYPE, Eventhdlr
+
+def attach_primal_dual_evolution_eventhdlr(model: Model):
+    """
+    Attaches an event handler to a given SCIP model that collects primal and dual solutions,
+    along with the solving time when they were found.
+    The data is saved in model.data["primal_log"] and model.data["dual_log"]. They consist of
+    a list of tuples, each tuple containing the solving time and the corresponding solution.
+
+    A usage example can be found in examples/finished/plot_primal_dual_evolution.py. The
+    example takes the information provided by this recipe and uses it to plot the evolution
+    of the dual and primal bounds over time. 
+    """
+    class GapEventhdlr(Eventhdlr):
+
+        def eventinit(self): # we want to collect best primal solutions and best dual solutions
+            self.model.catchEvent(SCIP_EVENTTYPE.BESTSOLFOUND, self)
+            self.model.catchEvent(SCIP_EVENTTYPE.LPSOLVED, self)
+            self.model.catchEvent(SCIP_EVENTTYPE.NODESOLVED, self)
+            
+
+        def eventexec(self, event):
+            # if a new best primal solution was found, we save when it was found and also its objective
+            if event.getType() == SCIP_EVENTTYPE.BESTSOLFOUND:
+                self.model.data["primal_log"].append([self.model.getSolvingTime(), self.model.getPrimalbound()])
+            
+            if not self.model.data["dual_log"]:
+                self.model.data["dual_log"].append([self.model.getSolvingTime(), self.model.getDualbound()])
+            
+            if self.model.getObjectiveSense() == "minimize":
+                if self.model.isGT(self.model.getDualbound(), self.model.data["dual_log"][-1][1]):
+                    self.model.data["dual_log"].append([self.model.getSolvingTime(), self.model.getDualbound()])
+            else:
+                if self.model.isLT(self.model.getDualbound(), self.model.data["dual_log"][-1][1]):
+                    self.model.data["dual_log"].append([self.model.getSolvingTime(), self.model.getDualbound()])
+                    
+
+    if not hasattr(model, "data") or model.data==None:
+        model.data = {}
+
+    model.data["primal_log"] = []
+    model.data["dual_log"] = []
+    hdlr = GapEventhdlr()
+    model.includeEventhdlr(hdlr, "gapEventHandler", "Event handler which collects primal and dual solution evolution")
+
+    return model