rtc-tools 2.5.2rc4__py3-none-any.whl → 2.6.0__py3-none-any.whl

rtctools/optimization/optimization_problem.py

@@ -3,7 +3,6 @@ from abc import ABCMeta, abstractmethod, abstractproperty
 from typing import Any, Dict, Iterator, List, Tuple, Union
 
 import casadi as ca
-
 import numpy as np
 
 from rtctools._internal.alias_tools import AliasDict
@@ -53,8 +52,12 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
 
         self.__mixed_integer = False
 
-    def optimize(self, preprocessing: bool = True, postprocessing: bool = True,
-                 log_solver_failure_as_error: bool = True) -> bool:
+    def optimize(
+        self,
+        preprocessing: bool = True,
+        postprocessing: bool = True,
+        log_solver_failure_as_error: bool = True,
+    ) -> bool:
         """
         Perform one initialize-transcribe-solve-finalize cycle.
 
@@ -65,8 +68,10 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         """
 
         # Deprecations / removals
-        if hasattr(self, 'initial_state'):
-            raise RuntimeError("Support for `initial_state()` has been removed. Please use `history()` instead.")
+        if hasattr(self, "initial_state"):
+            raise RuntimeError(
+                "Support for `initial_state()` has been removed. Please use `history()` instead."
+            )
 
         logger.info("Entering optimize()")
 
@@ -78,8 +83,7 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
             # Check if control inputs are bounded
             self.__check_bounds_control_input()
         else:
-            logger.debug(
-                'Skipping Preprocessing in OptimizationProblem.optimize()')
+            logger.debug("Skipping Preprocessing in OptimizationProblem.optimize()")
 
         # Transcribe problem
         discrete, lbx, ubx, lbg, ubg, x0, nlp = self.transcribe()
@@ -93,19 +97,19 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
 
         logger.debug("Creating solver")
 
-        if options.pop('expand', False):
+        if options.pop("expand", False):
             # NOTE: CasADi only supports the "expand" option for nlpsol. To
             # also be able to expand with e.g. qpsol, we do the expansion
             # ourselves here.
             logger.debug("Expanding objective and constraints to SX")
 
-            expand_f_g = ca.Function('f_g', [nlp['x']], [nlp['f'], nlp['g']]).expand()
-            X_sx = ca.SX.sym('X', *nlp['x'].shape)
+            expand_f_g = ca.Function("f_g", [nlp["x"]], [nlp["f"], nlp["g"]]).expand()
+            X_sx = ca.SX.sym("X", *nlp["x"].shape)
             f_sx, g_sx = expand_f_g(X_sx)
 
-            nlp['f'] = f_sx
-            nlp['g'] = g_sx
-            nlp['x'] = X_sx
+            nlp["f"] = f_sx
+            nlp["g"] = g_sx
+            nlp["x"] = X_sx
 
         # Debug check for non-linearity in constraints
         self.__debug_check_linearity_constraints(nlp)
@@ -114,34 +118,34 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         self.__debug_check_linear_independence(lbx, ubx, lbg, ubg, nlp)
 
         # Solver option
-        my_solver = options['solver']
-        del options['solver']
+        my_solver = options["solver"]
+        del options["solver"]
 
         # Already consumed
-        del options['optimized_num_dir']
+        del options["optimized_num_dir"]
 
         # Iteration callback
-        iteration_callback = options.pop('iteration_callback', None)
+        iteration_callback = options.pop("iteration_callback", None)
 
         # CasADi solver to use
-        casadi_solver = options.pop('casadi_solver')
+        casadi_solver = options.pop("casadi_solver")
         if isinstance(casadi_solver, str):
             casadi_solver = getattr(ca, casadi_solver)
 
         nlpsol_options = {**options}
 
         if self.__mixed_integer:
-            nlpsol_options['discrete'] = discrete
+            nlpsol_options["discrete"] = discrete
         if iteration_callback:
-            nlpsol_options['iteration_callback'] = iteration_callback
+            nlpsol_options["iteration_callback"] = iteration_callback
 
         # Remove ipopt and bonmin defaults if they are not used
-        if my_solver != 'ipopt':
-            nlpsol_options.pop('ipopt', None)
-        if my_solver != 'bonmin':
-            nlpsol_options.pop('bonmin', None)
+        if my_solver != "ipopt":
+            nlpsol_options.pop("ipopt", None)
+        if my_solver != "bonmin":
+            nlpsol_options.pop("bonmin", None)
 
-        solver = casadi_solver('nlp', my_solver, nlp, nlpsol_options)
+        solver = casadi_solver("nlp", my_solver, nlp, nlpsol_options)
 
         # Solve NLP
         logger.info("Calling solver")
@@ -149,9 +153,16 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         results = solver(x0=x0, lbx=lbx, ubx=ubx, lbg=ca.veccat(*lbg), ubg=ca.veccat(*ubg))
 
         # Extract relevant stats
-        self.__objective_value = float(results['f'])
-        self.__solver_output = np.array(results['x']).ravel()
-        self.__transcribed_problem = {"lbx": lbx, "ubx": ubx, "lbg": lbg, "ubg": ubg, "x0": x0, "nlp": nlp}
+        self.__objective_value = float(results["f"])
+        self.__solver_output = np.array(results["x"]).ravel()
+        self.__transcribed_problem = {
+            "lbx": lbx,
+            "ubx": ubx,
+            "lbg": lbg,
+            "ubg": ubg,
+            "x0": x0,
+            "nlp": nlp,
+        }
         self.__lam_g = results.get("lam_g")
         self.__lam_x = results.get("lam_x")
 
@@ -159,18 +170,22 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
 
         success, log_level = self.solver_success(self.__solver_stats, log_solver_failure_as_error)
 
-        return_status = self.__solver_stats['return_status']
-        if 'secondary_return_status' in self.__solver_stats:
-            return_status = "{}: {}".format(return_status, self.__solver_stats['secondary_return_status'])
+        return_status = self.__solver_stats["return_status"]
+        if "secondary_return_status" in self.__solver_stats:
+            return_status = "{}: {}".format(
+                return_status, self.__solver_stats["secondary_return_status"]
+            )
         wall_clock_time = "elapsed time not read"
-        if 't_wall_total' in self.__solver_stats:
-            wall_clock_time = "{} seconds".format(self.__solver_stats['t_wall_total'])
-        elif 't_wall_solver' in self.__solver_stats:
-            wall_clock_time = "{} seconds".format(self.__solver_stats['t_wall_solver'])
+        if "t_wall_total" in self.__solver_stats:
+            wall_clock_time = "{} seconds".format(self.__solver_stats["t_wall_total"])
+        elif "t_wall_solver" in self.__solver_stats:
+            wall_clock_time = "{} seconds".format(self.__solver_stats["t_wall_solver"])
 
         if success:
-            logger.log(log_level, "Solver succeeded with status {} ({}).".format(
-                return_status, wall_clock_time))
+            logger.log(
+                log_level,
+                "Solver succeeded with status {} ({}).".format(return_status, wall_clock_time),
+            )
         else:
             try:
                 ii = [y[0] for y in self.loop_over_error].index(self.priority)
@@ -182,18 +197,21 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
                 except IndexError:
                     if loop_error_indicator:
                         log_level = logging.INFO
-                logger.log(log_level, "Solver succeeded with status {} ({}).".format(
-                    return_status, wall_clock_time))
+                logger.log(
+                    log_level,
+                    "Solver succeeded with status {} ({}).".format(return_status, wall_clock_time),
+                )
             except (AttributeError, ValueError):
-                logger.log(log_level, "Solver succeeded with status {} ({}).".format(
-                    return_status, wall_clock_time))
+                logger.log(
+                    log_level,
+                    "Solver succeeded with status {} ({}).".format(return_status, wall_clock_time),
+                )
 
         # Do any postprocessing
         if postprocessing:
             self.post()
         else:
-            logger.debug(
-                'Skipping Postprocessing in OptimizationProblem.optimize()')
+            logger.debug("Skipping Postprocessing in OptimizationProblem.optimize()")
 
         # Done
         logger.info("Done with optimize()")
@@ -201,18 +219,23 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         return success
 
     def __check_bounds_control_input(self) -> None:
-        # Checks if at the control inputs have bounds, log warning when a control input is not bounded.
+        # Checks if at the control inputs have bounds, log warning when a control input is not
+        # bounded.
         bounds = self.bounds()
 
-        for variable in self.dae_variables['control_inputs']:
+        for variable in self.dae_variables["control_inputs"]:
             variable = variable.name()
             if variable not in bounds:
                 logger.warning(
-                    "OptimizationProblem: control input {} has no bounds.".format(variable))
+                    "OptimizationProblem: control input {} has no bounds.".format(variable)
+                )
 
     @abstractmethod
-    def transcribe(self) -> Tuple[
-            np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, Dict[str, ca.MX]]:
+    def transcribe(
+        self,
+    ) -> Tuple[
+        np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, Dict[str, ca.MX]
+    ]:
         """
         Transcribe the continuous optimization problem to a discretized, solver-ready
         optimization problem.
@@ -223,34 +246,35 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         """
         Returns a dictionary of CasADi optimization problem solver options.
 
-        The default solver for continuous problems is `Ipopt <https://projects.coin-or.org/Ipopt/>`_.
-        The default solver for mixed integer problems is `Bonmin <http://projects.coin-or.org/Bonmin/>`_.
+        The default solver for continuous problems is `Ipopt
+        <https://projects.coin-or.org/Ipopt/>`_.
+
+        The default solver for mixed integer problems is `Bonmin
+        <http://projects.coin-or.org/Bonmin/>`_.
 
         :returns: A dictionary of solver options. See the CasADi and
                   respective solver documentation for details.
         """
-        options = {'error_on_fail': False,
-                   'optimized_num_dir': 3,
-                   'casadi_solver': ca.nlpsol}
+        options = {"error_on_fail": False, "optimized_num_dir": 3, "casadi_solver": ca.nlpsol}
 
         if self.__mixed_integer:
-            options['solver'] = 'bonmin'
+            options["solver"] = "bonmin"
 
-            bonmin_options = options['bonmin'] = {}
-            bonmin_options['algorithm'] = 'B-BB'
-            bonmin_options['nlp_solver'] = 'Ipopt'
-            bonmin_options['nlp_log_level'] = 2
-            bonmin_options['linear_solver'] = 'mumps'
+            bonmin_options = options["bonmin"] = {}
+            bonmin_options["algorithm"] = "B-BB"
+            bonmin_options["nlp_solver"] = "Ipopt"
+            bonmin_options["nlp_log_level"] = 2
+            bonmin_options["linear_solver"] = "mumps"
         else:
-            options['solver'] = 'ipopt'
+            options["solver"] = "ipopt"
 
-            ipopt_options = options['ipopt'] = {}
-            ipopt_options['linear_solver'] = 'mumps'
+            ipopt_options = options["ipopt"] = {}
+            ipopt_options["linear_solver"] = "mumps"
         return options
 
-    def solver_success(self,
-                       solver_stats: Dict[str, Union[str, bool]],
-                       log_solver_failure_as_error: bool) -> Tuple[bool, int]:
+    def solver_success(
+        self, solver_stats: Dict[str, Union[str, bool]], log_solver_failure_as_error: bool
+    ) -> Tuple[bool, int]:
         """
         Translates the returned solver statistics into a boolean and log level
         to indicate whether the solve was succesful, and how to log it.
@@ -276,13 +300,15 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         For example, this can happen when too many goals are specified, and
         lower priority goals cannot improve further on the current result.
 
-        :returns: A tuple indicating whether or not the solver has succeeded, and what level to log it with.
+        :returns: A tuple indicating whether or not the solver has succeeded, and what level to log
+            it with.
         """
-        success = solver_stats['success']
+        success = solver_stats["success"]
         log_level = logging.INFO if success else logging.ERROR
 
-        if (self.solver_options()['solver'].lower() in ['bonmin', 'ipopt']
-                and solver_stats['return_status'] in ['Not_Enough_Degrees_Of_Freedom']):
+        if self.solver_options()["solver"].lower() in ["bonmin", "ipopt"] and solver_stats[
+            "return_status"
+        ] in ["Not_Enough_Degrees_Of_Freedom"]:
             log_level = logging.WARNING
 
         if log_level == logging.ERROR and not log_solver_failure_as_error:
@@ -395,8 +421,8 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
 
     def delayed_feedback(self) -> List[Tuple[str, str, float]]:
         """
-        Returns the delayed feedback mappings.  These are given as a list of triples :math:`(x, y, \\tau)`,
-        to indicate that :math:`y = x(t - \\tau)`.
+        Returns the delayed feedback mappings.  These are given as a list of triples
+        :math:`(x, y, \\tau)`, to indicate that :math:`y = x(t - \\tau)`.
 
         :returns: A list of triples.
 
@@ -515,7 +541,10 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
             elif isinstance(v1, np.ndarray) and isinstance(v2, Timeseries):
                 if v2.values.ndim != 2 or len(v1) != v2.values.shape[1]:
                     raise Exception(
-                        "Mismatching vector size when upcasting to Timeseries, {} vs. {}.".format(v1, v2))
+                        "Mismatching vector size when upcasting to Timeseries, {} vs. {}.".format(
+                            v1, v2
+                        )
+                    )
                 all_bounds[i] = Timeseries(v2.times, np.broadcast_to(v1, v2.values.shape))
             elif isinstance(v1, (int, float)) and isinstance(v2, np.ndarray):
                 all_bounds[i] = np.full_like(v2, v1)
@@ -582,7 +611,8 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
 
         :param ensemble_member: The ensemble member index.
 
-        :returns: A dictionary of variable names and historical time series (up to and including t0).
+        :returns:
+            A dictionary of variable names and historical time series (up to and including t0).
         """
         return AliasDict(self.alias_relation)
 
@@ -639,7 +669,8 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         """
         The objective function for the given ensemble member.
 
-        Call :func:`OptimizationProblem.state_at` to return a symbol representing a model variable at a given time.
+        Call :func:`OptimizationProblem.state_at` to return a symbol representing a model variable
+        at a given time.
 
         :param ensemble_member: The ensemble member index.
 
@@ -677,12 +708,14 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         """
         return ca.MX(0)
 
-    def constraints(self, ensemble_member: int) -> List[
-            Tuple[ca.MX, Union[float, np.ndarray], Union[float, np.ndarray]]]:
+    def constraints(
+        self, ensemble_member: int
+    ) -> List[Tuple[ca.MX, Union[float, np.ndarray], Union[float, np.ndarray]]]:
         """
         Returns a list of constraints for the given ensemble member.
 
-        Call :func:`OptimizationProblem.state_at` to return a symbol representing a model variable at a given time.
+        Call :func:`OptimizationProblem.state_at` to return a symbol representing a model variable
+        at a given time.
 
         :param ensemble_member: The ensemble member index.
 
@@ -705,8 +738,9 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         """
         return []
 
-    def path_constraints(self, ensemble_member: int) -> List[
-            Tuple[ca.MX, Union[float, np.ndarray], Union[float, np.ndarray]]]:
+    def path_constraints(
+        self, ensemble_member: int
+    ) -> List[Tuple[ca.MX, Union[float, np.ndarray], Union[float, np.ndarray]]]:
         """
         Returns a list of path constraints.
 
@@ -751,13 +785,14 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
     INTERPOLATION_PIECEWISE_CONSTANT_BACKWARD = 2
 
     def interpolate(
-            self,
-            t: Union[float, np.ndarray],
-            ts: np.ndarray,
-            fs: np.ndarray,
-            f_left: float = np.nan,
-            f_right: float = np.nan,
-            mode: int = INTERPOLATION_LINEAR) -> Union[float, np.ndarray]:
+        self,
+        t: Union[float, np.ndarray],
+        ts: np.ndarray,
+        fs: np.ndarray,
+        f_left: float = np.nan,
+        f_right: float = np.nan,
+        mode: int = INTERPOLATION_LINEAR,
+    ) -> Union[float, np.ndarray]:
         """
         Linear interpolation over time.
 
@@ -779,9 +814,11 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
                 # Early termination; nothing to interpolate
                 return fs.copy()
 
-            fs_int = [self.interpolate(t, ts, fs[:, i], f_left, f_right, mode) for i in range(fs.shape[1])]
+            fs_int = [
+                self.interpolate(t, ts, fs[:, i], f_left, f_right, mode) for i in range(fs.shape[1])
+            ]
             return np.stack(fs_int, axis=1)
-        elif hasattr(t, '__iter__'):
+        elif hasattr(t, "__iter__"):
             if len(t) == len(ts) and np.all(t == ts):
                 # Early termination; nothing to interpolate
                 return fs.copy()
@@ -807,26 +844,26 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         :param f_right: Function value right of rightmost time stamp.
         :param mode:    Interpolation mode.
 
-        Note that it is assumed that `ts` is sorted. No such assumption is made for `t`
-.
+        Note that it is assumed that `ts` is sorted. No such assumption is made for `t`.
+
         :returns: The interpolated value.
         """
 
         if f_left is None:
-            if (min(t) if hasattr(t, '__iter__') else t) < ts[0]:
+            if (min(t) if hasattr(t, "__iter__") else t) < ts[0]:
                 raise Exception("Interpolation: Point {} left of range".format(t))
 
         if f_right is None:
-            if (max(t) if hasattr(t, '__iter__') else t) > ts[-1]:
+            if (max(t) if hasattr(t, "__iter__") else t) > ts[-1]:
                 raise Exception("Interpolation: Point {} right of range".format(t))
 
         if mode == self.INTERPOLATION_LINEAR:
             # No need to handle f_left / f_right; NumPy already does this for us
             return np.interp(t, ts, fs, f_left, f_right)
         elif mode == self.INTERPOLATION_PIECEWISE_CONSTANT_FORWARD:
-            v = fs[np.maximum(np.searchsorted(ts, t, side='right') - 1, 0)]
+            v = fs[np.maximum(np.searchsorted(ts, t, side="right") - 1, 0)]
         elif mode == self.INTERPOLATION_PIECEWISE_CONSTANT_BACKWARD:
-            v = fs[np.minimum(np.searchsorted(ts, t, side='left'), len(ts) - 1)]
+            v = fs[np.minimum(np.searchsorted(ts, t, side="left"), len(ts) - 1)]
         else:
             raise NotImplementedError
 
@@ -850,8 +887,9 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def discretize_controls(self, resolved_bounds: AliasDict) -> Tuple[
-            int, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    def discretize_controls(
+        self, resolved_bounds: AliasDict
+    ) -> Tuple[int, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
         """
         Performs the discretization of the control inputs, filling lower and upper
         bound vectors for the resulting optimization variables, as well as an initial guess.
@@ -914,7 +952,9 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         return self.variable(variable)
 
     @abstractmethod
-    def control_at(self, variable: str, t: float, ensemble_member: int = 0, scaled: bool = False) -> ca.MX:
+    def control_at(
+        self, variable: str, t: float, ensemble_member: int = 0, scaled: bool = False
+    ) -> ca.MX:
         """
         Returns an :class:`MX` symbol representing the given control input at the given time.
 
@@ -944,8 +984,9 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def discretize_states(self, resolved_bounds: AliasDict) -> Tuple[
-            int, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    def discretize_states(
+        self, resolved_bounds: AliasDict
+    ) -> Tuple[int, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
         """
         Perform the discretization of the states.
 
@@ -1002,7 +1043,9 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         return self.variable(variable)
 
     @abstractmethod
-    def state_at(self, variable: str, t: float, ensemble_member: int = 0, scaled: bool = False) -> ca.MX:
+    def state_at(
+        self, variable: str, t: float, ensemble_member: int = 0, scaled: bool = False
+    ) -> ca.MX:
         """
         Returns an :class:`MX` symbol representing the given variable at the given time.
 
@@ -1032,7 +1075,9 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def states_in(self, variable: str, t0: float = None, tf: float = None, ensemble_member: int = 0) -> Iterator[ca.MX]:
+    def states_in(
+        self, variable: str, t0: float = None, tf: float = None, ensemble_member: int = 0
+    ) -> Iterator[ca.MX]:
         """
         Iterates over symbols for states in the interval [t0, tf].
 
@@ -1046,7 +1091,9 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def integral(self, variable: str, t0: float = None, tf: float = None, ensemble_member: int = 0) -> ca.MX:
+    def integral(
+        self, variable: str, t0: float = None, tf: float = None, ensemble_member: int = 0
+    ) -> ca.MX:
         """
         Returns an expression for the integral over the interval [t0, tf].
 
@@ -1104,12 +1151,13 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         raise NotImplementedError
 
     def set_timeseries(
-            self,
-            variable: str,
-            timeseries: Timeseries,
-            ensemble_member: int = 0,
-            output: bool = True,
-            check_consistency: bool = True) -> None:
+        self,
+        variable: str,
+        timeseries: Timeseries,
+        ensemble_member: int = 0,
+        output: bool = True,
+        check_consistency: bool = True,
+    ) -> None:
         """
         Sets a timeseries in the internal data store.
 
@@ -1149,19 +1197,19 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
 
     @debug_check(DebugLevel.HIGH)
     def __debug_check_linearity_constraints(self, nlp):
-        x = nlp['x']
-        f = nlp['f']
-        g = nlp['g']
+        x = nlp["x"]
+        f = nlp["f"]
+        g = nlp["g"]
 
-        expand_f_g = ca.Function('f_g', [x], [f, g]).expand()
-        X_sx = ca.SX.sym('X', *x.shape)
+        expand_f_g = ca.Function("f_g", [x], [f, g]).expand()
+        X_sx = ca.SX.sym("X", *x.shape)
         f_sx, g_sx = expand_f_g(X_sx)
 
-        jac = ca.Function('j', [X_sx], [ca.jacobian(g_sx, X_sx)]).expand()
+        jac = ca.Function("j", [X_sx], [ca.jacobian(g_sx, X_sx)]).expand()
         if jac(np.nan).is_regular():
             logger.info("The constraints are linear")
         else:
-            hes = ca.Function('j', [X_sx], [ca.jacobian(ca.jacobian(g_sx, X_sx), X_sx)]).expand()
+            hes = ca.Function("j", [X_sx], [ca.jacobian(ca.jacobian(g_sx, X_sx), X_sx)]).expand()
             if hes(np.nan).is_regular():
                 logger.info("The constraints are quadratic")
             else:
@@ -1169,12 +1217,12 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
 
     @debug_check(DebugLevel.VERYHIGH)
     def __debug_check_linear_independence(self, lbx, ubx, lbg, ubg, nlp):
-        x = nlp['x']
-        f = nlp['f']
-        g = nlp['g']
+        x = nlp["x"]
+        f = nlp["f"]
+        g = nlp["g"]
 
-        expand_f_g = ca.Function('f_g', [x], [f, g]).expand()
-        x_sx = ca.SX.sym('X', *x.shape)
+        expand_f_g = ca.Function("f_g", [x], [f, g]).expand()
+        x_sx = ca.SX.sym("X", *x.shape)
         f_sx, g_sx = expand_f_g(x_sx)
 
         x, f, g = x_sx, f_sx, g_sx
@@ -1183,18 +1231,18 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
         ubg = np.array(ca.vertsplit(ca.veccat(*ubg))).ravel()
 
         # Find the linear constraints
-        g_sjac = ca.Function('Af', [x], [ca.jtimes(g, x, x.ones(*x.shape))])
+        g_sjac = ca.Function("Af", [x], [ca.jtimes(g, x, x.ones(*x.shape))])
 
         res = g_sjac(np.nan)
         res = np.array(res).ravel()
         g_is_linear = ~np.isnan(res)
 
         # Find the rows in the jacobian with only a single entry
-        g_jac_csr = ca.DM(ca.Function('tmp', [x], [g]).sparsity_jac(0, 0)).tocsc().tocsr()
-        g_single_variable = (np.diff(g_jac_csr.indptr) == 1)
+        g_jac_csr = ca.DM(ca.Function("tmp", [x], [g]).sparsity_jac(0, 0)).tocsc().tocsr()
+        g_single_variable = np.diff(g_jac_csr.indptr) == 1
 
         # Find the rows which are equality constraints
-        g_eq_constraint = (lbg == ubg)
+        g_eq_constraint = lbg == ubg
 
         # The intersection of all selections are constraints like we want
         g_constant_assignment = g_is_linear & g_single_variable & g_eq_constraint
@@ -1210,7 +1258,11 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
 
         for vi, g_inds in var_index_assignment.items():
             if len(g_inds) > 1:
-                logger.info("Variable '{}' has duplicate constraints setting its value:".format(var_names[vi]))
+                logger.info(
+                    "Variable '{}' has duplicate constraints setting its value:".format(
+                        var_names[vi]
+                    )
+                )
                 for g_i in g_inds:
                     logger.info("row {}: {} = {}".format(g_i, named_g[g_i], lbg[g_i]))
 
@@ -1221,7 +1273,9 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
 
         for vi in x_inds:
             if vi in var_index_assignment:
-                logger.info("Variable '{}' has equal bounds (value = {}), but also the following equality constraints:"
-                            .format(var_names[vi], lbx[vi]))
+                logger.info(
+                    "Variable '{}' has equal bounds (value = {}), "
+                    "but also the following equality constraints:".format(var_names[vi], lbx[vi])
+                )
                 for g_i in var_index_assignment[vi]:
                     logger.info("row {}: {} = {}".format(g_i, named_g[g_i], lbg[g_i]))