Add type hints and type loop variables

src/pyscipopt/benders.pxi

@@ -176,6 +176,8 @@ cdef SCIP_RETCODE PyBendersPostsolve (SCIP* scip, SCIP_BENDERS* benders, SCIP_SO
         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
+    cdef int i
+
     bendersdata = SCIPbendersGetData(benders)
     PyBenders = <Benders>bendersdata
     if sol == NULL:

src/pyscipopt/branchrule.pxi

@@ -23,16 +23,16 @@ cdef class Branchrule:
         '''informs branching rule that the branch and bound process data is being freed'''
         pass
 
-    def branchexeclp(self, allowaddcons):
+    def branchexeclp(self, SCIP_Bool allowaddcons):
         '''executes branching rule for fractional LP solution'''
         raise NotImplementedError("branchexeclp() is a fundamental callback and should be implemented in the derived "
                                   "class")
 
-    def branchexecext(self, allowaddcons):
+    def branchexecext(self, SCIP_Bool allowaddcons):
         '''executes branching rule for external branching candidates '''
         raise NotImplementedError("branchexecext() is a fundamental callback and should be implemented in the derived class")
 
-    def branchexecps(self, allowaddcons):
+    def branchexecps(self, SCIP_Bool allowaddcons):
         '''executes branching rule for not completely fixed pseudo solution '''
         # this method needs to be implemented by the user
         raise NotImplementedError("branchexecps() is a fundamental callback and should be implemented in the derived class")

src/pyscipopt/conshdlr.pxi

@@ -29,7 +29,7 @@ cdef class Conshdlr:
         '''informs constraint handler that the branch and bound process is being started '''
         pass
 
-    def consexitsol(self, constraints, restart):
+    def consexitsol(self, constraints, SCIP_Bool restart):
         '''informs constraint handler that the branch and bound process data is being freed '''
         pass
 
@@ -45,74 +45,74 @@ cdef class Conshdlr:
         '''calls LP initialization method of constraint handler to separate all initial active constraints '''
         return {}
 
-    def conssepalp(self, constraints, nusefulconss):
+    def conssepalp(self, constraints, int nusefulconss):
         '''calls separator method of constraint handler to separate LP solution '''
         return {}
 
-    def conssepasol(self, constraints, nusefulconss, solution):
+    def conssepasol(self, constraints, int nusefulconss, Solution solution):
         '''calls separator method of constraint handler to separate given primal solution '''
         return {}
 
-    def consenfolp(self, constraints, nusefulconss, solinfeasible):
+    def consenfolp(self, constraints, int nusefulconss, SCIP_Bool solinfeasible):
         '''calls enforcing method of constraint handler for LP solution for all constraints added'''
         print("python error in consenfolp: this method needs to be implemented")
         return {}
 
-    def consenforelax(self, solution, constraints, nusefulconss, solinfeasible):
+    def consenforelax(self, Solution solution, constraints, int nusefulconss, solinfeasible):
         '''calls enforcing method of constraint handler for a relaxation solution for all constraints added'''
         print("python error in consenforelax: this method needs to be implemented")
         return {}
 
-    def consenfops(self, constraints, nusefulconss, solinfeasible, objinfeasible):
+    def consenfops(self, constraints, int nusefulconss, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible):
         '''calls enforcing method of constraint handler for pseudo solution for all constraints added'''
         print("python error in consenfops: this method needs to be implemented")
         return {}
 
-    def conscheck(self, constraints, solution, checkintegrality, checklprows, printreason, completely):
+    def conscheck(self, constraints, Solution solution, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely):
         '''calls feasibility check method of constraint handler '''
         print("python error in conscheck: this method needs to be implemented")
         return {}
 
-    def consprop(self, constraints, nusefulconss, nmarkedconss, proptiming):
+    def consprop(self, constraints, int nusefulconss, int nmarkedconss, SCIP_PROPTIMING proptiming):
         '''calls propagation method of constraint handler '''
         return {}
 
-    def conspresol(self, constraints, nrounds, presoltiming,
-                   nnewfixedvars, nnewaggrvars, nnewchgvartypes, nnewchgbds, nnewholes,
-                   nnewdelconss, nnewaddconss, nnewupgdconss, nnewchgcoefs, nnewchgsides, result_dict):
+    def conspresol(self, constraints, int nrounds, SCIP_PRESOLTIMING presoltiming,
+                   int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes,
+                   int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, result_dict):
         '''calls presolving method of constraint handler '''
         return result_dict
 
     def consresprop(self):
         '''sets propagation conflict resolving method of constraint handler '''
         return {}
 
-    def conslock(self, constraint, locktype, nlockspos, nlocksneg):
+    def conslock(self, constraint: Union[Constraint, ExprCons], int locktype, int nlockspos, int nlocksneg):
         '''variable rounding lock method of constraint handler'''
         print("python error in conslock: this method needs to be implemented")
         return {}
 
-    def consactive(self, constraint):
+    def consactive(self, constraint: Union[Constraint, ExprCons]):
         '''sets activation notification method of constraint handler '''
         pass
 
-    def consdeactive(self, constraint):
+    def consdeactive(self, constraint: Union[Constraint, ExprCons]):
         '''sets deactivation notification method of constraint handler '''
         pass
 
-    def consenable(self, constraint):
+    def consenable(self, constraint: Union[Constraint, ExprCons]):
         '''sets enabling notification method of constraint handler '''
         pass
 
-    def consdisable(self, constraint):
+    def consdisable(self, constraint: Union[Constraint, ExprCons]):
         '''sets disabling notification method of constraint handler '''
         pass
 
-    def consdelvars(self, constraints):
+    def consdelvars(self, constraint: Union[Constraint, ExprCons]):
         '''calls variable deletion method of constraint handler'''
         pass
 
-    def consprint(self, constraint):
+    def consprint(self, constraint: Union[Constraint, ExprCons]):
         '''sets constraint display method of constraint handler '''
         pass
 
@@ -124,11 +124,11 @@ cdef class Conshdlr:
         '''sets constraint parsing method of constraint handler '''
         pass
 
-    def consgetvars(self, constraint):
+    def consgetvars(self, constraint: Union[Constraint, ExprCons]):
         '''sets constraint variable getter method of constraint handler'''
         pass
 
-    def consgetnvars(self, constraint):
+    def consgetnvars(self, constraint: Union[Constraint, ExprCons]):
         '''sets constraint variable number getter method of constraint handler '''
         return {}
 
@@ -170,6 +170,7 @@ cdef SCIP_RETCODE PyConsFree (SCIP* scip, SCIP_CONSHDLR* conshdlr) noexcept with
 cdef SCIP_RETCODE PyConsInit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
     PyConshdlr = getPyConshdlr(conshdlr)
     cdef constraints = []
+    cdef int i
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     PyConshdlr.consinit(constraints)
@@ -178,6 +179,7 @@ cdef SCIP_RETCODE PyConsInit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** c
 cdef SCIP_RETCODE PyConsExit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
     PyConshdlr = getPyConshdlr(conshdlr)
     cdef constraints = []
+    cdef int i
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     PyConshdlr.consexit(constraints)
@@ -186,6 +188,7 @@ cdef SCIP_RETCODE PyConsExit (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** c
 cdef SCIP_RETCODE PyConsInitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
     PyConshdlr = getPyConshdlr(conshdlr)
     cdef constraints = []
+    cdef int i
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     PyConshdlr.consinitpre(constraints)
@@ -194,6 +197,7 @@ cdef SCIP_RETCODE PyConsInitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS*
 cdef SCIP_RETCODE PyConsExitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
     PyConshdlr = getPyConshdlr(conshdlr)
     cdef constraints = []
+    cdef int i
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     PyConshdlr.consexitpre(constraints)
@@ -202,6 +206,7 @@ cdef SCIP_RETCODE PyConsExitpre (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS*
 cdef SCIP_RETCODE PyConsInitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
     PyConshdlr = getPyConshdlr(conshdlr)
     cdef constraints = []
+    cdef int i
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     PyConshdlr.consinitsol(constraints)
@@ -210,6 +215,7 @@ cdef SCIP_RETCODE PyConsInitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS*
 cdef SCIP_RETCODE PyConsExitsol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool restart) noexcept with gil:
     PyConshdlr = getPyConshdlr(conshdlr)
     cdef constraints = []
+    cdef int i
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     PyConshdlr.consexitsol(constraints, restart)
@@ -246,6 +252,7 @@ cdef SCIP_RETCODE PyConsTrans (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* s
 cdef SCIP_RETCODE PyConsInitlp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool* infeasible) noexcept with gil:
     PyConshdlr = getPyConshdlr(conshdlr)
     cdef constraints = []
+    cdef int i
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     result_dict = PyConshdlr.consinitlp(constraints)
@@ -255,6 +262,7 @@ cdef SCIP_RETCODE PyConsInitlp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS**
 cdef SCIP_RETCODE PyConsSepalp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_RESULT* result) noexcept with gil:
     PyConshdlr = getPyConshdlr(conshdlr)
     cdef constraints = []
+    cdef int i
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     result_dict = PyConshdlr.conssepalp(constraints, nusefulconss)
@@ -265,6 +273,7 @@ cdef SCIP_RETCODE PyConsSepasol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS*
                                  SCIP_SOL* sol, SCIP_RESULT* result) noexcept with gil:
     PyConshdlr = getPyConshdlr(conshdlr)
     cdef constraints = []
+    cdef int i
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     solution = Solution.create(scip, sol)
@@ -276,6 +285,7 @@ cdef SCIP_RETCODE PyConsEnfolp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS**
                                 SCIP_Bool solinfeasible, SCIP_RESULT* result) noexcept with gil:
     PyConshdlr = getPyConshdlr(conshdlr)
     cdef constraints = []
+    cdef int i
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     result_dict = PyConshdlr.consenfolp(constraints, nusefulconss, solinfeasible)
@@ -285,6 +295,7 @@ cdef SCIP_RETCODE PyConsEnfolp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS**
 cdef SCIP_RETCODE PyConsEnforelax (SCIP* scip, SCIP_SOL* sol, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, SCIP_Bool solinfeasible, SCIP_RESULT* result) noexcept with gil:
     PyConshdlr = getPyConshdlr(conshdlr)
     cdef constraints = []
+    cdef int i
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     solution = Solution.create(scip, sol)
@@ -296,6 +307,7 @@ cdef SCIP_RETCODE PyConsEnfops (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS**
                                 SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT* result) noexcept with gil:
     PyConshdlr = getPyConshdlr(conshdlr)
     cdef constraints = []
+    cdef int i
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     result_dict = PyConshdlr.consenfops(constraints, nusefulconss, solinfeasible, objinfeasible)
@@ -306,6 +318,7 @@ cdef SCIP_RETCODE PyConsCheck (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS**
                                SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT* result) noexcept with gil:
     PyConshdlr = getPyConshdlr(conshdlr)
     cdef constraints = []
+    cdef int i
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     solution = Solution.create(scip, sol)
@@ -317,6 +330,7 @@ cdef SCIP_RETCODE PyConsProp (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** c
                               SCIP_PROPTIMING proptiming, SCIP_RESULT* result) noexcept with gil:
     PyConshdlr = getPyConshdlr(conshdlr)
     cdef constraints = []
+    cdef int i
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     result_dict = PyConshdlr.consprop(constraints, nusefulconss, nmarkedconss, proptiming)
@@ -330,6 +344,7 @@ cdef SCIP_RETCODE PyConsPresol (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS**
                                 int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result) noexcept with gil:
     PyConshdlr = getPyConshdlr(conshdlr)
     cdef constraints = []
+    cdef int i
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     # dictionary for input/output parameters
@@ -403,6 +418,7 @@ cdef SCIP_RETCODE PyConsDisable (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS*
 cdef SCIP_RETCODE PyConsDelvars (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss) noexcept with gil:
     PyConshdlr = getPyConshdlr(conshdlr)
     cdef constraints = []
+    cdef int i
     for i in range(nconss):
         constraints.append(getPyCons(conss[i]))
     PyConshdlr.consdelvars(constraints)

src/pyscipopt/cutsel.pxi

@@ -23,7 +23,7 @@ cdef class Cutsel:
     '''executed before the branch-and-bound process is freed'''
     pass
 
-  def cutselselect(self, cuts, forcedcuts, root, maxnselectedcuts):
+  def cutselselect(self, list[SCIP_ROW] cuts, int forcedcuts, SCIP_Bool root, int maxnselectedcuts):
     '''first method called in each iteration in the main solving loop. '''
     # this method needs to be implemented by the user
     return {}
@@ -74,9 +74,10 @@ cdef SCIP_RETCODE PyCutselSelect (SCIP* scip, SCIP_CUTSEL* cutsel, SCIP_ROW** cu
                                   int* nselectedcuts, SCIP_RESULT* result) noexcept with gil:
   cdef SCIP_CUTSELDATA* cutseldata
   cdef SCIP_ROW* scip_row
+  cdef int i
   cutseldata = SCIPcutselGetData(cutsel)
   PyCutsel = <Cutsel>cutseldata
-
+  
   # translate cuts to python
   pycuts = [Row.create(cuts[i]) for i in range(ncuts)]
   pyforcedcuts = [Row.create(forcedcuts[i]) for i in range(nforcedcuts)]

src/pyscipopt/expr.pxi

@@ -54,7 +54,7 @@ def _is_number(e):
         return False
 
 
-def _expr_richcmp(self, other, op):
+def _expr_richcmp(self, other, int op):
     if op == 1: # <=
         if isinstance(other, Expr) or isinstance(other, GenExpr):
             return (self - other) <= 0.0
@@ -90,7 +90,7 @@ class Term:
         self.ptrtuple = tuple(v.ptr() for v in self.vartuple)
         self.hashval = sum(self.ptrtuple)
 
-    def __getitem__(self, idx):
+    def __getitem__(self, int idx):
         return self.vartuple[idx]
 
     def __hash__(self):
@@ -115,6 +115,7 @@ CONST = Term()
 # helper function
 def buildGenExprObj(expr):
     """helper function to generate an object of type GenExpr"""
+    cdef SCIP_Real coef
     if _is_number(expr):
         return Constant(expr)
     elif isinstance(expr, Expr):
@@ -143,7 +144,7 @@ def buildGenExprObj(expr):
 #See also the @ref ExprDetails "description" in the expr.pxi. 
 cdef class Expr:
 
-    def __init__(self, terms=None):
+    def __init__(self, terms: Union[None, dict[Variable,SCIP_Real]] = None):
         '''terms is a dict of variables to coefficients.
 
         CONST is used as key for the constant term.'''
@@ -620,23 +621,23 @@ cdef class Constant(GenExpr):
     def __repr__(self):
         return str(self.number)
 
-def exp(expr):
+def exp(expr: Union[Expr, GenExpr]):
     """returns expression with exp-function"""
     return UnaryExpr(Operator.exp, buildGenExprObj(expr))
-def log(expr):
+def log(expr: Union[Expr, GenExpr]):
     """returns expression with log-function"""
     return UnaryExpr(Operator.log, buildGenExprObj(expr))
-def sqrt(expr):
+def sqrt(expr: Union[Expr, GenExpr]):
     """returns expression with sqrt-function"""
     return UnaryExpr(Operator.sqrt, buildGenExprObj(expr))
-def sin(expr):
+def sin(expr: Union[Expr, GenExpr]):
     """returns expression with sin-function"""
     return UnaryExpr(Operator.sin, buildGenExprObj(expr))
-def cos(expr):
+def cos(expr: Union[Expr, GenExpr]):
     """returns expression with cos-function"""
     return UnaryExpr(Operator.cos, buildGenExprObj(expr))
 
-def expr_to_nodes(expr):
+def expr_to_nodes(expr: Union[Expr, GenExpr]):
     '''transforms tree to an array of nodes. each node is an operator and the position of the 
     children of that operator (i.e. the other nodes) in the array'''
     assert isinstance(expr, GenExpr)

src/pyscipopt/heuristic.pxi

@@ -24,7 +24,7 @@ cdef class Heur:
         '''informs primal heuristic that the branch and bound process data is being freed'''
         pass
 
-    def heurexec(self, heurtiming, nodeinfeasible):
+    def heurexec(self, SCIP_HEURTIMING heurtiming, SCIP_Bool nodeinfeasible):
         '''should the heuristic the executed at the given depth, frequency, timing,...'''
         print("python error in heurexec: this method needs to be implemented")
         return {}