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

rtctools/optimization/goal_programming_mixin_base.py

@@ -6,7 +6,6 @@ from collections import OrderedDict
 from typing import Callable, Dict, List, Union
 
 import casadi as ca
-
 import numpy as np
 
 from .optimization_problem import OptimizationProblem
@@ -177,11 +176,14 @@ class Goal(metaclass=ABCMeta):
         * The goal size determines how many goals there are.
         * The goal function has shape ``(goal size, 1)``.
         * The function is either minimized or has, possibly various, targets.
-        * Function nominal can either be an array with as many entries as the goal size or have a single value.
-        * Function ranges can either be an array with as many entries as the goal size or have a single value.
-        * In a goal, the target can either be an array with as many entries as the goal size or have a single value.
-        * In a path goal, the target can also be a Timeseries whose values are either a 1-dimensional vector or have
-          as many columns as the goal size.
+        * Function nominal can either be an array with as many entries as the goal size or have a
+          single value.
+        * Function ranges can either be an array with as many entries as the goal size or have a
+          single value.
+        * In a goal, the target can either be an array with as many entries as the goal size or
+          have a single value.
+        * In a path goal, the target can also be a Timeseries whose values are either a
+          1-dimensional vector or have as many columns as the goal size.
 
     **Examples**
 
@@ -289,12 +291,16 @@ class Goal(metaclass=ABCMeta):
         """
         ``True`` if the user goal has min/max bounds.
         """
-        return (self.has_target_min or self.has_target_max)
+        return self.has_target_min or self.has_target_max
 
     @property
     def is_empty(self) -> bool:
-        target_min_set = isinstance(self.target_min, Timeseries) or np.any(np.isfinite(self.target_min))
-        target_max_set = isinstance(self.target_max, Timeseries) or np.any(np.isfinite(self.target_max))
+        target_min_set = isinstance(self.target_min, Timeseries) or np.any(
+            np.isfinite(self.target_min)
+        )
+        target_max_set = isinstance(self.target_max, Timeseries) or np.any(
+            np.isfinite(self.target_max)
+        )
 
         if not target_min_set and not target_max_set:
             # A minimization goal
@@ -313,25 +319,28 @@ class Goal(metaclass=ABCMeta):
 
         return min_empty and max_empty
 
-    def get_function_key(self, optimization_problem: OptimizationProblem, ensemble_member: int) -> str:
+    def get_function_key(
+        self, optimization_problem: OptimizationProblem, ensemble_member: int
+    ) -> str:
         """
         Returns a key string uniquely identifying the goal function.  This
         is used to eliminate linearly dependent constraints from the optimization problem.
         """
-        if hasattr(self, 'function_key'):
+        if hasattr(self, "function_key"):
             return self.function_key
 
         # This must be deterministic.  See RTCTOOLS-485.
-        if not hasattr(Goal, '_function_key_counter'):
+        if not hasattr(Goal, "_function_key_counter"):
             Goal._function_key_counter = 0
-        self.function_key = '{}_{}'.format(self.__class__.__name__, Goal._function_key_counter)
+        self.function_key = "{}_{}".format(self.__class__.__name__, Goal._function_key_counter)
         Goal._function_key_counter += 1
 
         return self.function_key
 
     def __repr__(self) -> str:
-        return '{}(priority={}, target_min={}, target_max={}, function_range={})'.format(
-            self.__class__, self.priority, self.target_min, self.target_max, self.function_range)
+        return "{}(priority={}, target_min={}, target_max={}, function_range={})".format(
+            self.__class__, self.priority, self.target_min, self.target_max, self.function_range
+        )
 
 
 class StateGoal(Goal):
@@ -362,9 +371,9 @@ class StateGoal(Goal):
 
         my_state_goal = MyStateGoal(optimization_problem)
 
-    Note that ``StateGoal`` is a helper class.  State goals can also be defined using ``Goal`` as direct base class,
-    by implementing the ``function`` method and providing the ``function_range`` and ``function_nominal``
-    class variables manually.
+    Note that ``StateGoal`` is a helper class.  State goals can also be defined using ``Goal`` as
+    direct base class, by implementing the ``function`` method and providing the
+    ``function_range`` and ``function_nominal`` class variables manually.
 
     """
 
@@ -380,45 +389,52 @@ class StateGoal(Goal):
 
         # Check whether a state has been specified
         if self.state is None:
-            raise Exception('Please specify a state.')
+            raise Exception("Please specify a state.")
 
         # Extract state range from model
         if self.has_target_bounds:
             try:
                 self.function_range = optimization_problem.bounds()[self.state]
             except KeyError:
-                raise Exception('State {} has no bounds or does not exist in the model.'.format(self.state))
+                raise Exception(
+                    "State {} has no bounds or does not exist in the model.".format(self.state)
+                )
 
             if self.function_range[0] is None:
-                raise Exception('Please provide a lower bound for state {}.'.format(self.state))
+                raise Exception("Please provide a lower bound for state {}.".format(self.state))
             if self.function_range[1] is None:
-                raise Exception('Please provide an upper bound for state {}.'.format(self.state))
+                raise Exception("Please provide an upper bound for state {}.".format(self.state))
 
         # Extract state nominal from model
         self.function_nominal = optimization_problem.variable_nominal(self.state)
 
         # Set function key
         canonical, sign = optimization_problem.alias_relation.canonical_signed(self.state)
-        self.function_key = canonical if sign > 0.0 else '-' + canonical
+        self.function_key = canonical if sign > 0.0 else "-" + canonical
 
     def function(self, optimization_problem, ensemble_member):
         return optimization_problem.state(self.state)
 
     def __repr__(self):
-        return '{}(priority={}, state={}, target_min={}, target_max={}, function_range={})'.format(
-            self.__class__, self.priority, self.state, self.target_min, self.target_max, self.function_range)
+        return "{}(priority={}, state={}, target_min={}, target_max={}, function_range={})".format(
+            self.__class__,
+            self.priority,
+            self.state,
+            self.target_min,
+            self.target_max,
+            self.function_range,
+        )
 
 
 class _GoalConstraint:
-
     def __init__(
-            self,
-            goal: Goal,
-            function: Callable[[OptimizationProblem], ca.MX],
-            m: Union[float, np.ndarray, Timeseries],
-            M: Union[float, np.ndarray, Timeseries],
-            optimized: bool):
-
+        self,
+        goal: Goal,
+        function: Callable[[OptimizationProblem], ca.MX],
+        m: Union[float, np.ndarray, Timeseries],
+        M: Union[float, np.ndarray, Timeseries],
+        optimized: bool,
+    ):
         assert isinstance(m, (float, np.ndarray, Timeseries))
         assert isinstance(M, (float, np.ndarray, Timeseries))
         assert type(m) == type(M)
@@ -434,7 +450,7 @@ class _GoalConstraint:
         self.max = M
         self.optimized = optimized
 
-    def update_bounds(self, other, enforce='self'):
+    def update_bounds(self, other, enforce="self"):
         # NOTE: a.update_bounds(b) is _not_ the same as  b.update_bounds(a).
         # See how the 'enforce' parameter is used.
 
@@ -456,7 +472,7 @@ class _GoalConstraint:
 
         # Ensure new constraint bounds do not loosen or shift
         # previous bounds due to numerical errors.
-        if enforce == 'self':
+        if enforce == "self":
             min_ = np.minimum(max_, other_min)
             max_ = np.maximum(min_, other_max)
         else:
@@ -476,16 +492,19 @@ class _GoalConstraint:
 
 
 class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
-
     def _gp_n_objectives(self, subproblem_objectives, subproblem_path_objectives, ensemble_member):
-        return ca.vertcat(*[o(self, ensemble_member) for o in subproblem_objectives]).size1() \
+        return (
+            ca.vertcat(*[o(self, ensemble_member) for o in subproblem_objectives]).size1()
             + ca.vertcat(*[o(self, ensemble_member) for o in subproblem_path_objectives]).size1()
+        )
 
     def _gp_objective(self, subproblem_objectives, n_objectives, ensemble_member):
         if len(subproblem_objectives) > 0:
-            acc_objective = ca.sum1(ca.vertcat(*[o(self, ensemble_member) for o in subproblem_objectives]))
+            acc_objective = ca.sum1(
+                ca.vertcat(*[o(self, ensemble_member) for o in subproblem_objectives])
+            )
 
-            if self.goal_programming_options()['scale_by_problem_size']:
+            if self.goal_programming_options()["scale_by_problem_size"]:
                 acc_objective = acc_objective / n_objectives
 
             return acc_objective
@@ -494,9 +513,11 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
 
     def _gp_path_objective(self, subproblem_path_objectives, n_objectives, ensemble_member):
         if len(subproblem_path_objectives) > 0:
-            acc_objective = ca.sum1(ca.vertcat(*[o(self, ensemble_member) for o in subproblem_path_objectives]))
+            acc_objective = ca.sum1(
+                ca.vertcat(*[o(self, ensemble_member) for o in subproblem_path_objectives])
+            )
 
-            if self.goal_programming_options()['scale_by_problem_size']:
+            if self.goal_programming_options()["scale_by_problem_size"]:
                 # Objective is already divided by number of active time steps
                 # at this point when `scale_by_problem_size` is set.
                 acc_objective = acc_objective / n_objectives
@@ -540,8 +561,7 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
 
         m, M = None, None
         if isinstance(g.target_min, Timeseries):
-            m = self.interpolate(
-                times, g.target_min.times, g.target_min.values, -np.inf, -np.inf)
+            m = self.interpolate(times, g.target_min.times, g.target_min.values, -np.inf, -np.inf)
             if m.ndim > 1:
                 m = m.transpose()
         elif isinstance(g.target_min, np.ndarray) and target_shape:
@@ -551,8 +571,7 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
         else:
             m = np.array([g.target_min]).transpose()
         if isinstance(g.target_max, Timeseries):
-            M = self.interpolate(
-                times, g.target_max.times, g.target_max.values, np.inf, np.inf)
+            M = self.interpolate(times, g.target_max.times, g.target_max.values, np.inf, np.inf)
             if M.ndim > 1:
                 M = M.transpose()
         elif isinstance(g.target_max, np.ndarray) and target_shape:
@@ -570,7 +589,7 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
         if g.size > 1:
             assert m.shape == (g.size, 1 if target_shape is None else target_shape)
         else:
-            assert m.shape == (1 if target_shape is None else target_shape, )
+            assert m.shape == (1 if target_shape is None else target_shape,)
         assert m.shape == M.shape
 
         return m, M
@@ -623,7 +642,9 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
                     raise Exception("Goal weight should be positive for goal {}".format(goal))
             else:
                 if goal.function_range != (np.nan, np.nan):
-                    raise Exception("Specifying function range not allowed for goal {}".format(goal))
+                    raise Exception(
+                        "Specifying function range not allowed for goal {}".format(goal)
+                    )
 
             if not is_path_goal:
                 if isinstance(goal.target_min, Timeseries):
@@ -636,15 +657,25 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
             except ValueError:
                 raise Exception("Priority of not int or castable to int for goal {}".format(goal))
 
-            if options['keep_soft_constraints']:
+            if options["keep_soft_constraints"]:
                 if goal.relaxation != 0.0:
-                    raise Exception("Relaxation not allowed with `keep_soft_constraints` for goal {}".format(goal))
+                    raise Exception(
+                        "Relaxation not allowed with `keep_soft_constraints` for goal {}".format(
+                            goal
+                        )
+                    )
                 if goal.violation_timeseries_id is not None:
                     raise Exception(
-                        "Violation timeseries id not allowed with `keep_soft_constraints` for goal {}".format(goal))
+                        "Violation timeseries id not allowed with "
+                        "`keep_soft_constraints` for goal {}".format(goal)
+                    )
             else:
                 if goal.size > 1:
-                    raise Exception("Option `keep_soft_constraints` needs to be set for vector goal {}".format(goal))
+                    raise Exception(
+                        "Option `keep_soft_constraints` needs to be set for vector goal {}".format(
+                            goal
+                        )
+                    )
 
             if goal.critical and goal.size > 1:
                 raise Exception("Vector goal cannot be critical for goal {}".format(goal))
@@ -657,7 +688,7 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
         # Check consistency and monotonicity of goals. Scalar target min/max
         # of normal goals are also converted to arrays to unify checks with
         # path goals.
-        if options['check_monotonicity']:
+        if options["check_monotonicity"]:
             for e in range(self.ensemble_size):
                 # Store the previous goal of a certain function key we
                 # encountered, such that we can compare to it.
@@ -672,21 +703,25 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
                         goal_m, goal_M = self._gp_min_max_arrays(goal, target_shape)
                         other_m, other_M = self._gp_min_max_arrays(prev, target_shape)
 
-                        indices = np.where(np.logical_not(np.logical_or(
-                            np.isnan(goal_m), np.isnan(other_m))))
+                        indices = np.where(
+                            np.logical_not(np.logical_or(np.isnan(goal_m), np.isnan(other_m)))
+                        )
                         if goal.has_target_min:
                             if np.any(goal_m[indices] < other_m[indices]):
                                 raise Exception(
-                                    'Target minimum of goal {} must be greater or equal than '
-                                    'target minimum of goal {}.'.format(goal, prev))
+                                    "Target minimum of goal {} must be greater or equal than "
+                                    "target minimum of goal {}.".format(goal, prev)
+                                )
 
-                        indices = np.where(np.logical_not(np.logical_or(
-                            np.isnan(goal_M), np.isnan(other_M))))
+                        indices = np.where(
+                            np.logical_not(np.logical_or(np.isnan(goal_M), np.isnan(other_M)))
+                        )
                         if goal.has_target_max:
                             if np.any(goal_M[indices] > other_M[indices]):
                                 raise Exception(
-                                    'Target maximum of goal {} must be less or equal than '
-                                    'target maximum of goal {}'.format(goal, prev))
+                                    "Target maximum of goal {} must be less or equal than "
+                                    "target maximum of goal {}".format(goal, prev)
+                                )
 
         for goal in goals:
             goal_m, goal_M = self._gp_min_max_arrays(goal, target_shape)
@@ -694,35 +729,42 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
             goal_ub = np.broadcast_to(goal.function_range[1], goal_M.shape[::-1]).transpose()
 
             if goal.has_target_min and goal.has_target_max:
-                indices = np.where(np.logical_not(np.logical_or(
-                    np.isnan(goal_m), np.isnan(goal_M))))
+                indices = np.where(
+                    np.logical_not(np.logical_or(np.isnan(goal_m), np.isnan(goal_M)))
+                )
 
                 if np.any(goal_m[indices] > goal_M[indices]):
-                    raise Exception("Target minimum exceeds target maximum for goal {}".format(goal))
+                    raise Exception(
+                        "Target minimum exceeds target maximum for goal {}".format(goal)
+                    )
 
             if goal.has_target_min and not goal.critical:
                 indices = np.where(np.isfinite(goal_m))
                 if np.any(goal_m[indices] <= goal_lb[indices]):
                     raise Exception(
-                        'Target minimum should be greater than the lower bound of the function range for goal {}'
-                        .format(goal))
+                        "Target minimum should be greater than the lower bound "
+                        "of the function range for goal {}".format(goal)
+                    )
                 if np.any(goal_m[indices] > goal_ub[indices]):
                     raise Exception(
-                        'Target minimum should not be greater than the upper bound of the function range for goal {}'
-                        .format(goal))
+                        "Target minimum should not be greater than the upper bound "
+                        "of the function range for goal {}".format(goal)
+                    )
             if goal.has_target_max and not goal.critical:
                 indices = np.where(np.isfinite(goal_M))
                 if np.any(goal_M[indices] >= goal_ub[indices]):
                     raise Exception(
-                        'Target maximum should be smaller than the upper bound of the function range for goal {}'
-                        .format(goal))
+                        "Target maximum should be smaller than the upper bound "
+                        "of the function range for goal {}".format(goal)
+                    )
                 if np.any(goal_M[indices] < goal_lb[indices]):
                     raise Exception(
-                        'Target maximum should not be smaller than the lower bound of the function range for goal {}'
-                        .format(goal))
+                        "Target maximum should not be smaller than the lower bound "
+                        "of the function range for goal {}".format(goal)
+                    )
 
             if goal.relaxation < 0.0:
-                raise Exception('Relaxation of goal {} should be a nonnegative value'.format(goal))
+                raise Exception("Relaxation of goal {} should be a nonnegative value".format(goal))
 
     def _gp_goal_constraints(self, goals, sym_index, options, is_path_goal):
         """
@@ -772,10 +814,14 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
 
                 if isinstance(goal.target_min, Timeseries):
                     target_min = Timeseries(goal.target_min.times, goal.target_min.values)
-                    inds = np.logical_or(np.isnan(target_min.values), np.isneginf(target_min.values))
+                    inds = np.logical_or(
+                        np.isnan(target_min.values), np.isneginf(target_min.values)
+                    )
                     target_min.values[inds] = -sys.float_info.max
                     n_times = len(goal.target_min.times)
-                    target_min_slice_inds = ~np.all(np.broadcast_to(inds.transpose(), (goal.size, n_times)), axis=1)
+                    target_min_slice_inds = ~np.all(
+                        np.broadcast_to(inds.transpose(), (goal.size, n_times)), axis=1
+                    )
                 elif isinstance(goal.target_min, np.ndarray):
                     target_min = goal.target_min.copy()
                     inds = np.logical_or(np.isnan(target_min), np.isneginf(target_min))
@@ -795,10 +841,14 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
 
                 if isinstance(goal.target_max, Timeseries):
                     target_max = Timeseries(goal.target_max.times, goal.target_max.values)
-                    inds = np.logical_or(np.isnan(target_max.values), np.isposinf(target_max.values))
+                    inds = np.logical_or(
+                        np.isnan(target_max.values), np.isposinf(target_max.values)
+                    )
                     target_max.values[inds] = sys.float_info.max
                     n_times = len(goal.target_max.times)
-                    target_max_slice_inds = ~np.all(np.broadcast_to(inds.transpose(), (goal.size, n_times)), axis=1)
+                    target_max_slice_inds = ~np.all(
+                        np.broadcast_to(inds.transpose(), (goal.size, n_times)), axis=1
+                    )
                 elif isinstance(goal.target_max, np.ndarray):
                     target_max = goal.target_max.copy()
                     inds = np.logical_or(np.isnan(target_max), np.isposinf(target_max))
@@ -813,11 +863,13 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
 
             # Make objective for soft constraints and minimization goals
             if not goal.critical:
-                if hasattr(goal, '_objective_func'):
+                if hasattr(goal, "_objective_func"):
                     _objective_func = goal._objective_func
                 elif goal.has_target_bounds:
-                    if is_path_goal and options['scale_by_problem_size']:
-                        goal_m, goal_M = self._gp_min_max_arrays(goal, target_shape=len(self.times()))
+                    if is_path_goal and options["scale_by_problem_size"]:
+                        goal_m, goal_M = self._gp_min_max_arrays(
+                            goal, target_shape=len(self.times())
+                        )
                         goal_active = np.isfinite(goal_m) | np.isfinite(goal_M)
                         n_active = np.sum(goal_active.astype(int), axis=-1)
                         # Avoid possible division by zero if goal is inactive
@@ -825,23 +877,34 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
                     else:
                         n_active = 1
 
-                    def _objective_func(problem, ensemble_member,
-                                        goal=goal, epsilon=epsilon, is_path_goal=is_path_goal,
-                                        n_active=n_active):
+                    def _objective_func(
+                        problem,
+                        ensemble_member,
+                        goal=goal,
+                        epsilon=epsilon,
+                        is_path_goal=is_path_goal,
+                        n_active=n_active,
+                    ):
                         if is_path_goal:
                             epsilon = problem.variable(epsilon.name())
                         else:
                             epsilon = problem.extra_variable(epsilon.name(), ensemble_member)
 
                         return goal.weight * ca.constpow(epsilon, goal.order) / n_active
+
                 else:
-                    if is_path_goal and options['scale_by_problem_size']:
+                    if is_path_goal and options["scale_by_problem_size"]:
                         n_active = len(self.times())
                     else:
                         n_active = 1
 
-                    def _objective_func(problem, ensemble_member, goal=goal, is_path_goal=is_path_goal,
-                                        n_active=n_active):
+                    def _objective_func(
+                        problem,
+                        ensemble_member,
+                        goal=goal,
+                        is_path_goal=is_path_goal,
+                        n_active=n_active,
+                    ):
                         f = goal.function(problem, ensemble_member) / goal.function_nominal
                         return goal.weight * ca.constpow(f, goal.order) / n_active
 
@@ -852,15 +915,23 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
                 if goal.critical:
                     for ensemble_member in range(self.ensemble_size):
                         constraint = self._gp_goal_hard_constraint(
-                            goal, epsilon, None, ensemble_member, options, is_path_goal)
+                            goal, epsilon, None, ensemble_member, options, is_path_goal
+                        )
                         hard_constraints[ensemble_member].append(constraint)
                 else:
                     for ensemble_member in range(self.ensemble_size):
                         # We use a violation variable formulation, with the violation
                         # variables epsilon bounded between 0 and 1.
-                        def _soft_constraint_func(problem, target, bound, inds,
-                                                  goal=goal, epsilon=epsilon, ensemble_member=ensemble_member,
-                                                  is_path_constraint=is_path_goal):
+                        def _soft_constraint_func(
+                            problem,
+                            target,
+                            bound,
+                            inds,
+                            goal=goal,
+                            epsilon=epsilon,
+                            ensemble_member=ensemble_member,
+                            is_path_constraint=is_path_goal,
+                        ):
                             if is_path_constraint:
                                 target = problem.variable(target)
                                 eps = problem.variable(epsilon.name())
@@ -873,16 +944,19 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
                             f = goal.function(problem, ensemble_member)
                             nominal = goal.function_nominal
 
-                            return ca.if_else(ca.fabs(target) < sys.float_info.max,
-                                              (f - eps * (bound - target) - target) / nominal,
-                                              0.0)[inds]
+                            return ca.if_else(
+                                ca.fabs(target) < sys.float_info.max,
+                                (f - eps * (bound - target) - target) / nominal,
+                                0.0,
+                            )[inds]
 
                         if goal.has_target_min and np.any(target_min_slice_inds):
                             _f = functools.partial(
                                 _soft_constraint_func,
                                 target=min_variable,
                                 bound=goal.function_range[0],
-                                inds=target_min_slice_inds)
+                                inds=target_min_slice_inds,
+                            )
                             constraint = _GoalConstraint(goal, _f, 0.0, np.inf, False)
                             soft_constraints[ensemble_member].append(constraint)
                         if goal.has_target_max and np.any(target_max_slice_inds):
@@ -890,13 +964,16 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
                                 _soft_constraint_func,
                                 target=max_variable,
                                 bound=goal.function_range[1],
-                                inds=target_max_slice_inds)
+                                inds=target_max_slice_inds,
+                            )
                             constraint = _GoalConstraint(goal, _f, -np.inf, 0.0, False)
                             soft_constraints[ensemble_member].append(constraint)
 
         return epsilons, objectives, soft_constraints, hard_constraints, extra_constants
 
-    def _gp_goal_hard_constraint(self, goal, epsilon, existing_constraint, ensemble_member, options, is_path_goal):
+    def _gp_goal_hard_constraint(
+        self, goal, epsilon, existing_constraint, ensemble_member, options, is_path_goal
+    ):
         if not is_path_goal:
             epsilon = epsilon[:1]
 
@@ -905,21 +982,29 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
         if goal.has_target_bounds:
             # We use a violation variable formulation, with the violation
             # variables epsilon bounded between 0 and 1.
-            m, M = np.full_like(epsilon, -np.inf, dtype=np.float64), np.full_like(epsilon, np.inf, dtype=np.float64)
+            m, M = np.full_like(epsilon, -np.inf, dtype=np.float64), np.full_like(
+                epsilon, np.inf, dtype=np.float64
+            )
 
             # A function range does not have to be specified for critical
             # goals. Avoid multiplying with NaN in that case.
             if goal.has_target_min:
-                m = (epsilon * ((goal.function_range[0] - goal_m) if not goal.critical else 0.0)
-                     + goal_m - goal.relaxation) / goal.function_nominal
+                m = (
+                    epsilon * ((goal.function_range[0] - goal_m) if not goal.critical else 0.0)
+                    + goal_m
+                    - goal.relaxation
+                ) / goal.function_nominal
             if goal.has_target_max:
-                M = (epsilon * ((goal.function_range[1] - goal_M) if not goal.critical else 0.0)
-                     + goal_M + goal.relaxation) / goal.function_nominal
+                M = (
+                    epsilon * ((goal.function_range[1] - goal_M) if not goal.critical else 0.0)
+                    + goal_M
+                    + goal.relaxation
+                ) / goal.function_nominal
 
             if goal.has_target_min and goal.has_target_max:
                 # Avoid comparing with NaN
                 inds = ~(np.isnan(m) | np.isnan(M))
-                inds[inds] &= np.abs(m[inds] - M[inds]) < options['equality_threshold']
+                inds[inds] &= np.abs(m[inds] - M[inds]) < options["equality_threshold"]
                 if np.any(inds):
                     avg = 0.5 * (m + M)
                     m[inds] = M[inds] = avg[inds]
@@ -927,31 +1012,35 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
             m[~np.isfinite(goal_m)] = -np.inf
             M[~np.isfinite(goal_M)] = np.inf
 
-            inds = epsilon > options['violation_tolerance']
+            inds = epsilon > options["violation_tolerance"]
             if np.any(inds):
                 if is_path_goal:
-                    expr = self.map_path_expression(goal.function(self, ensemble_member), ensemble_member)
+                    expr = self.map_path_expression(
+                        goal.function(self, ensemble_member), ensemble_member
+                    )
                 else:
                     expr = goal.function(self, ensemble_member)
 
-                function = ca.Function('f', [self.solver_input], [expr])
+                function = ca.Function("f", [self.solver_input], [expr])
                 value = np.array(function(self.solver_output))
 
                 m[inds] = (value - goal.relaxation) / goal.function_nominal
                 M[inds] = (value + goal.relaxation) / goal.function_nominal
 
-            m -= options['constraint_relaxation']
-            M += options['constraint_relaxation']
+            m -= options["constraint_relaxation"]
+            M += options["constraint_relaxation"]
         else:
             # Epsilon encodes the position within the function range.
-            if options['fix_minimized_values'] and goal.relaxation == 0.0:
+            if options["fix_minimized_values"] and goal.relaxation == 0.0:
                 m = epsilon / goal.function_nominal
                 M = epsilon / goal.function_nominal
                 self.check_collocation_linearity = False
                 self.linear_collocation = False
             else:
                 m = -np.inf * np.ones(epsilon.shape)
-                M = (epsilon + goal.relaxation) / goal.function_nominal + options['constraint_relaxation']
+                M = (epsilon + goal.relaxation) / goal.function_nominal + options[
+                    "constraint_relaxation"
+                ]
 
         if is_path_goal:
             m = Timeseries(self.times(), m)
@@ -963,13 +1052,17 @@ class _GoalProgrammingMixinBase(OptimizationProblem, metaclass=ABCMeta):
         constraint = _GoalConstraint(
             goal,
             lambda problem, ensemble_member=ensemble_member, goal=goal: (
-                goal.function(problem, ensemble_member) / goal.function_nominal),
-            m, M, True)
+                goal.function(problem, ensemble_member) / goal.function_nominal
+            ),
+            m,
+            M,
+            True,
+        )
 
         # Epsilon is fixed. Override previous {min,max} constraints for this
         # state.
         if existing_constraint:
-            constraint.update_bounds(existing_constraint, enforce='other')
+            constraint.update_bounds(existing_constraint, enforce="other")
 
         return constraint