desdeo 2.0.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

desdeo/tools/scalarization.py

@@ -6,6 +6,8 @@ or minimization of the corresponding objective functions may be correctly
 accounted for when computing scalarization function values.
 """
 
+from typing import Literal
+
 import numpy as np
 
 from desdeo.problem import (
@@ -17,9 +19,9 @@ from desdeo.problem import (
     VariableTypeEnum,
 )
 from desdeo.tools.utils import (
+    flip_maximized_objective_values,
     get_corrected_ideal,
     get_corrected_nadir,
-    get_corrected_reference_point,
 )
 
 
@@ -192,7 +194,7 @@ def add_asf_nondiff(  # noqa: PLR0913
     # Build the max term
     max_operands = [
         (
-            f"({obj.symbol}_min - {reference_point[obj.symbol]}{" * -1" if obj.maximize else ''}) "
+            f"({obj.symbol}_min - {reference_point[obj.symbol]}{' * -1' if obj.maximize else ''}) "
             f"/ ({nadir_point[obj.symbol]} - ({ideal_point[obj.symbol]} - {delta}))"
         )
         for obj in problem.objectives
@@ -208,7 +210,7 @@ def add_asf_nondiff(  # noqa: PLR0913
     else:
         aug_operands = [
             (
-                f"({obj.symbol}_min - {reference_point[obj.symbol]}{" * -1" if obj.maximize else 1}) "
+                f"({obj.symbol}_min - {reference_point[obj.symbol]}{' * -1' if obj.maximize else 1}) "
                 f"/ ({nadir_point[obj.symbol]} - ({ideal_point[obj.symbol]} - {delta}))"
             )
             for obj in problem.objectives
@@ -230,231 +232,6 @@ def add_asf_nondiff(  # noqa: PLR0913
     return problem.add_scalarization(scalarization_function), symbol
 
 
-def add_group_asf(
-    problem: Problem,
-    symbol: str,
-    reference_points: list[dict[str, float]],
-    ideal: dict[str, float] | None = None,
-    nadir: dict[str, float] | None = None,
-    delta: float = 1e-6,
-    rho: float = 1e-6,
-) -> tuple[Problem, str]:
-    r"""Add the achievement scalarizing function for multiple decision makers.
-
-    The scalarization function is defined as follows:
-
-    \begin{align}
-        &\mbox{minimize} &&\max_{i,d} [w_{id}(f_{id}(\mathbf{x})-\overline{z}_{id})] +
-        \rho \sum^k_{i=1} \sum^{n_d}_{d=1} w_{id}f_{id}(\mathbf{x}) \\
-        &\mbox{subject to} &&\mathbf{x} \in \mathbf{X},
-    \end{align}
-
-    where $w_{id} = \frac{1}{z^{nad}_{id} - z^{uto}_{id}}$.
-
-    Args:
-        problem (Problem): the problem to which the scalarization function should be added.
-        symbol (str): the symbol to reference the added scalarization function.
-        reference_points (list[dict[str, float]]): a list of reference points as objective dicts.
-        ideal (dict[str, float], optional): ideal point values. If not given, attempt will be made
-            to calculate ideal point from problem.
-        nadir (dict[str, float], optional): nadir point values. If not given, attempt will be made
-            to calculate nadir point from problem.
-        delta (float, optional): a small scalar used to define the utopian point. Defaults to 1e-6.
-        rho (float, optional): the weight factor used in the augmentation term. Defaults to 1e-6.
-
-    Raises:
-        ScalarizationError: there are missing elements in any reference point.
-
-    Returns:
-        tuple[Problem, str]: A tuple containing a copy of the problem with the scalarization function added,
-            and the symbol of the added scalarization function.
-    """
-    # check reference points
-    for reference_point in reference_points:
-        if not objective_dict_has_all_symbols(problem, reference_point):
-            msg = f"The give reference point {reference_point} is missing a value for one or more objectives."
-            raise ScalarizationError(msg)
-
-    # check if ideal point is specified
-    # if not specified, try to calculate corrected ideal point
-    if ideal is not None:
-        ideal_point = ideal
-    elif problem.get_ideal_point() is not None:
-        ideal_point = get_corrected_ideal(problem)
-    else:
-        msg = "Ideal point not defined!"
-        raise ScalarizationError(msg)
-
-    # check if nadir point is specified
-    # if not specified, try to calculate corrected nadir point
-    if nadir is not None:
-        nadir_point = nadir
-    elif problem.get_nadir_point() is not None:
-        nadir_point = get_corrected_nadir(problem)
-    else:
-        msg = "Nadir point not defined!"
-        raise ScalarizationError(msg)
-
-    # calculate the weights
-    weights = {
-        obj.symbol: 1 / (nadir_point[obj.symbol] - (ideal_point[obj.symbol] - delta)) for obj in problem.objectives
-    }
-
-    # form the max and augmentation terms
-    max_terms = []
-    aug_exprs = []
-    for i in range(len(reference_points)):
-        corrected_rp = get_corrected_reference_point(problem, reference_points[i])
-        for obj in problem.objectives:
-            max_terms.append(f"({weights[obj.symbol]}) * ({obj.symbol}_min - {corrected_rp[obj.symbol]})")
-
-        aug_expr = " + ".join([f"({weights[obj.symbol]} * {obj.symbol}_min)" for obj in problem.objectives])
-        aug_exprs.append(aug_expr)
-    max_terms = ", ".join(max_terms)
-    aug_exprs = " + ".join(aug_exprs)
-
-    func = f"{Op.MAX}({max_terms}) + {rho} * ({aug_exprs})"
-
-    scalarization_function = ScalarizationFunction(
-        name="Achievement scalarizing function for multiple decision makers",
-        symbol=symbol,
-        func=func,
-        is_convex=problem.is_convex,
-        is_linear=problem.is_linear,
-        is_twice_differentiable=False,
-    )
-    return problem.add_scalarization(scalarization_function), symbol
-
-
-def add_group_asf_diff(
-    problem: Problem,
-    symbol: str,
-    reference_points: list[dict[str, float]],
-    ideal: dict[str, float] | None = None,
-    nadir: dict[str, float] | None = None,
-    delta: float = 1e-6,
-    rho: float = 1e-6,
-) -> tuple[Problem, str]:
-    r"""Add the differentiable variant of the achievement scalarizing function for multiple decision makers.
-
-    The scalarization function is defined as follows:
-
-    \begin{align}
-        &\mbox{minimize} &&\alpha +
-        \rho \sum^k_{i=1} \sum^{n_d}_{d=1} w_{id}f_{id}(\mathbf{x}) \\
-        &\mbox{subject to} && w_{id}(f_{id}(\mathbf{x})-\overline{z}_{id}) - \alpha \leq 0,\\
-        &&&\mathbf{x} \in \mathbf{X},
-    \end{align}
-
-    where $w_{id} = \frac{1}{z^{nad}_{id} - z^{uto}_{id}}$.
-
-    Args:
-        problem (Problem): the problem to which the scalarization function should be added.
-        symbol (str): the symbol to reference the added scalarization function.
-        reference_points (list[dict[str, float]]): a list of reference points as objective dicts.
-        ideal (dict[str, float], optional): ideal point values. If not given, attempt will be made
-            to calculate ideal point from problem.
-        nadir (dict[str, float], optional): nadir point values. If not given, attempt will be made
-            to calculate nadir point from problem.
-        delta (float, optional): a small scalar used to define the utopian point. Defaults to 1e-6.
-        rho (float, optional): the weight factor used in the augmentation term. Defaults to 1e-6.
-
-    Raises:
-        ScalarizationError: there are missing elements in any reference point.
-
-    Returns:
-        tuple[Problem, str]: A tuple containing a copy of the problem with the scalarization function added,
-            and the symbol of the added scalarization function.
-    """
-    # check reference points
-    for reference_point in reference_points:
-        if not objective_dict_has_all_symbols(problem, reference_point):
-            msg = f"The give reference point {reference_point} is missing a value for one or more objectives."
-            raise ScalarizationError(msg)
-
-    # check if ideal point is specified
-    # if not specified, try to calculate corrected ideal point
-    if ideal is not None:
-        ideal_point = ideal
-    elif problem.get_ideal_point() is not None:
-        ideal_point = get_corrected_ideal(problem)
-    else:
-        msg = "Ideal point not defined!"
-        raise ScalarizationError(msg)
-
-    # check if nadir point is specified
-    # if not specified, try to calculate corrected nadir point
-    if nadir is not None:
-        nadir_point = nadir
-    elif problem.get_nadir_point() is not None:
-        nadir_point = get_corrected_nadir(problem)
-    else:
-        msg = "Nadir point not defined!"
-        raise ScalarizationError(msg)
-
-    # define the auxiliary variable
-    alpha = Variable(
-        name="alpha",
-        symbol="_alpha",
-        variable_type=VariableTypeEnum.real,
-        lowerbound=-float("Inf"),
-        upperbound=float("Inf"),
-        initial_value=1.0,
-    )
-
-    # calculate the weights
-    weights = {
-        obj.symbol: 1 / (nadir_point[obj.symbol] - (ideal_point[obj.symbol] - delta)) for obj in problem.objectives
-    }
-
-    # form the constaint and augmentation expressions
-    # constraint expressions are formed into a list of lists
-    con_terms = []
-    aug_exprs = []
-    for i in range(len(reference_points)):
-        corrected_rp = get_corrected_reference_point(problem, reference_points[i])
-        rp = {}
-        for obj in problem.objectives:
-            rp[obj.symbol] = f"(({weights[obj.symbol]}) * ({obj.symbol}_min - {corrected_rp[obj.symbol]})) - _alpha"
-        con_terms.append(rp)
-        aug_expr = " + ".join([f"({weights[obj.symbol]} * {obj.symbol}_min)" for obj in problem.objectives])
-        aug_exprs.append(aug_expr)
-    aug_exprs = " + ".join(aug_exprs)
-
-    func = f"_alpha + {rho} * ({aug_exprs})"
-
-    scalarization_function = ScalarizationFunction(
-        name="Differentiable achievement scalarizing function for multiple decision makers",
-        symbol=symbol,
-        func=func,
-        is_convex=problem.is_convex,
-        is_linear=problem.is_linear,
-        is_twice_differentiable=problem.is_twice_differentiable,
-    )
-
-    constraints = []
-    # loop to create a constraint for every objective of every reference point given
-    for i in range(len(reference_points)):
-        for obj in problem.objectives:
-            # since we are subtracting a constant value, the linearity, convexity,
-            # and differentiability of the objective function, and hence the
-            # constraint, should not change.
-            constraints.append(
-                Constraint(
-                    name=f"Constraint for {obj.symbol}",
-                    symbol=f"{obj.symbol}_con_{i+1}",
-                    func=con_terms[i][obj.symbol],
-                    cons_type=ConstraintTypeEnum.LTE,
-                    is_linear=obj.is_linear,
-                    is_convex=obj.is_convex,
-                    is_twice_differentiable=obj.is_twice_differentiable,
-                )
-            )
-    _problem = problem.add_variables([alpha])
-    _problem = _problem.add_scalarization(scalarization_function)
-    return _problem.add_constraints(constraints), symbol
-
-
 def add_asf_generic_diff(  # noqa: PLR0913
     problem: Problem,
     symbol: str,
@@ -534,9 +311,9 @@ def add_asf_generic_diff(  # noqa: PLR0913
         msg = f"The given weight vector {weights_aug} is missing a value for one or more objectives."
         raise ScalarizationError(msg)
 
-    corrected_rp = get_corrected_reference_point(problem, reference_point)
+    corrected_rp = flip_maximized_objective_values(problem, reference_point)
     if reference_point_aug is not None:
-        corrected_rp_aug = get_corrected_reference_point(problem, reference_point_aug)
+        corrected_rp_aug = flip_maximized_objective_values(problem, reference_point_aug)
 
     # define the auxiliary variable
     alpha = Variable(
@@ -697,9 +474,9 @@ def add_asf_generic_nondiff(  # noqa: PLR0913
         raise ScalarizationError(msg)
 
     # get the corrected reference point
-    corrected_rp = get_corrected_reference_point(problem, reference_point)
+    corrected_rp = flip_maximized_objective_values(problem, reference_point)
     if reference_point_aug is not None:
-        corrected_rp_aug = get_corrected_reference_point(problem, reference_point_aug)
+        corrected_rp_aug = flip_maximized_objective_values(problem, reference_point_aug)
 
     # Build the max term
     max_operands = [
@@ -1132,7 +909,7 @@ def add_nimbus_sf_nondiff(  # noqa: PLR0913
         msg = "Nadir point not defined!"
         raise ScalarizationError(msg)
 
-    corrected_current_point = get_corrected_reference_point(problem, current_objective_vector)
+    corrected_current_point = flip_maximized_objective_values(problem, current_objective_vector)
 
     # max term and constraints
     max_args = []
@@ -1199,7 +976,7 @@ def add_nimbus_sf_nondiff(  # noqa: PLR0913
                 con_expr = f"{_symbol}_min - {-1 * reservation if obj.maximize else reservation}"
                 constraints.append(
                     Constraint(
-                        name=f"Worsen until constriant for {_symbol}",
+                        name=f"Worsen until constraint for {_symbol}",
                         symbol=f"{_symbol}_gte",
                         func=con_expr,
                         cons_type=ConstraintTypeEnum.LTE,
@@ -1241,101 +1018,54 @@ def add_nimbus_sf_nondiff(  # noqa: PLR0913
     return _problem.add_constraints(constraints), symbol
 
 
-def add_group_nimbus_sf(  # noqa: PLR0913
+def add_stom_sf_diff(
     problem: Problem,
     symbol: str,
-    classifications_list: list[dict[str, tuple[str, float | None]]],
-    current_objective_vector: dict[str, float],
+    reference_point: dict[str, float],
     ideal: dict[str, float] | None = None,
-    nadir: dict[str, float] | None = None,
-    delta: float = 0.000001,
-    rho: float = 0.000001,
+    rho: float = 1e-6,
+    delta: float = 1e-6,
 ) -> tuple[Problem, str]:
-    r"""Implements the multiple decision maker variant of the NIMBUS scalarization function.
-
-    The scalarization function is defined as follows:
-
-    \begin{align}
-        &\mbox{minimize} &&\max_{i\in I^<,j\in I^\leq,d} [w_{id}(f_{id}(\mathbf{x})-z^{ideal}_{id}),
-        w_{jd}(f_{jd}(\mathbf{x})-\hat{z}_{jd})] +
-        \rho \sum^k_{i=1} \sum^{n_d}_{d=1} w_{id}f_{id}(\mathbf{x}) \\
-        &\mbox{subject to} &&\mathbf{x} \in \mathbf{X},
-    \end{align}
-
-    where $w_{id} = \frac{1}{z^{nad}_{id} - z^{uto}_{id}}$, and $w_{jd} = \frac{1}{z^{nad}_{jd} - z^{uto}_{jd}}$.
-
-    The $I$-sets are related to the classifications given to each objective function value
-    in respect to  the current objective vector (e.g., by a decision maker). They
-    are as follows:
-
-    - $I^{<}$: values that should improve,
-    - $I^{\leq}$: values that should improve until a given aspiration level $\hat{z}_i$,
-    - $I^{=}$: values that are fine as they are,
-    - $I^{\geq}$: values that can be impaired until some reservation level $\varepsilon_i$, and
-    - $I^{\diamond}$: values that are allowed to change freely (not present explicitly in this scalarization function).
+    r"""Adds the differentiable variant of the STOM scalarizing function.
 
-    The aspiration levels and the reservation levels are supplied for each classification, when relevant, in
-    the argument `classifications` as follows:
+    \begin{align*}
+        \min \quad & \alpha + \rho \sum_{i=1}^k \frac{f_i(\mathbf{x})}{\bar{z}_i - z_i^{\star\star}} \\
+        \text{s.t.} \quad & \frac{f_i(\mathbf{x}) - z_i^{\star\star}}{\bar{z}_i
+        - z_i^{\star\star}} - \alpha \leq 0 \quad & \forall i = 1,\dots,k\\
+        & \mathbf{x} \in S,
+    \end{align*}
 
-    ```python
-    classifications = {
-        "f_1": ("<", None),
-        "f_2": ("<=", 42.1),
-        "f_3": (">=", 22.2),
-        "f_4": ("0", None)
-        }
-    ```
+    where $f_i$ are objective functions, $z_i^{\star\star} = z_i^\star - \delta$ is
+    a component of the utopian point, $\bar{z}_i$ is a component of the reference point,
+    $\rho$ and $\delta$ are small scalar values, $S$ is the feasible solution
+    space of the original problem,  and $\alpha$ is an auxiliary variable.
 
-    Here, we have assumed four objective functions. The key of the dict is a function's symbol, and the tuple
-    consists of a pair where the left element is the classification (self explanatory, '0' is for objective values
-    that may change freely), the right element is either `None` or an aspiration or a reservation level
-    depending on the classification.
+    References:
+        H. Nakayama, Y. Sawaragi, Satisficing trade-off method for
+            multiobjective programming, in: M. Grauer, A.P. Wierzbicki (Eds.),
+            Interactive Decision Analysis, Springer Verlag, Berlin, 1984, pp.
+            113-122.
 
     Args:
-        problem (Problem): the problem to be scalarized.
-        symbol (str): the symbol given to the scalarization function, i.e., target of the optimization.
-        classifications_list (list[dict[str, tuple[str, float  |  None]]]): a list of dicts, where the key is a symbol
-            of an objective function, and the value is a tuple with a classification and an aspiration
-            or a reservation level, or `None`, depending on the classification. See above for an
-            explanation.
-        current_objective_vector (dict[str, float]): the current objective vector that corresponds to
-            a Pareto optimal solution. The classifications are assumed to been given in respect to
-            this vector.
+        problem (Problem): the problem the scalarization is added to.
+        symbol (str): the symbol given to the added scalarization.
+        reference_point (dict[str, float]): a dict with keys corresponding to objective
+            function symbols and values to reference point components, i.e.,
+            aspiration levels.
         ideal (dict[str, float], optional): ideal point values. If not given, attempt will be made
             to calculate ideal point from problem.
-        nadir (dict[str, float], optional): nadir point values. If not given, attempt will be made
-            to calculate nadir point from problem.
-        delta (float, optional): a small scalar used to define the utopian point. Defaults to 0.000001.
-        rho (float, optional): a small scalar used in the augmentation term. Defaults to 0.000001.
-
-    Raises:
-        ScalarizationError: any of the given classifications do not define a classification
-            for all the objective functions or any of the given classifications do not allow at
-            least one objective function value to improve and one to worsen.
+        rho (float, optional): a small scalar value to scale the sum in the objective
+            function of the scalarization. Defaults to 1e-6.
+        delta (float, optional): a small scalar value to define the utopian point. Defaults to 1e-6.
 
     Returns:
         tuple[Problem, str]: a tuple with the copy of the problem with the added
             scalarization and the symbol of the added scalarization.
     """
-    # check that classifications have been provided for all objective functions
-    for classifications in classifications_list:
-        if not objective_dict_has_all_symbols(problem, classifications):
-            msg = (
-                f"The given classifications {classifications} do not define "
-                "a classification for all the objective functions."
-            )
-            raise ScalarizationError(msg)
-
-        # check that at least one objective function is allowed to be improved and one is
-        # allowed to worsen
-        if not any(classifications[obj.symbol][0] in ["<", "<="] for obj in problem.objectives) or not any(
-            classifications[obj.symbol][0] in [">=", "0"] for obj in problem.objectives
-        ):
-            msg = (
-                f"The given classifications {classifications} should allow at least one objective function value "
-                "to improve and one to worsen."
-            )
-            raise ScalarizationError(msg)
+    # check reference point
+    if not objective_dict_has_all_symbols(problem, reference_point):
+        msg = f"The give reference point {reference_point} is missing value for one or more objectives."
+        raise ScalarizationError(msg)
 
     # check if ideal point is specified
     # if not specified, try to calculate corrected ideal point
@@ -1347,475 +1077,42 @@ def add_group_nimbus_sf(  # noqa: PLR0913
         msg = "Ideal point not defined!"
         raise ScalarizationError(msg)
 
-    # check if nadir point is specified
-    # if not specified, try to calculate corrected nadir point
-    if nadir is not None:
-        nadir_point = nadir
-    elif problem.get_nadir_point() is not None:
-        nadir_point = get_corrected_nadir(problem)
-    else:
-        msg = "Nadir point not defined!"
-        raise ScalarizationError(msg)
-
-    corrected_current_point = get_corrected_reference_point(problem, current_objective_vector)
-
-    # calculate the weights
-    weights = {
-        obj.symbol: 1 / (nadir_point[obj.symbol] - (ideal_point[obj.symbol] - delta)) for obj in problem.objectives
-    }
-
-    # max term and constraints
-    max_args = []
-    constraints = []
+    corrected_rp = flip_maximized_objective_values(problem, reference_point)
 
-    for i in range(len(classifications_list)):
-        classifications = classifications_list[i]
-        for obj in problem.objectives:
-            _symbol = obj.symbol
-            match classifications[_symbol]:
-                case ("<", _):
-                    max_expr = f"{weights[_symbol]} * ({_symbol}_min - {ideal_point[_symbol]})"
-                    max_args.append(max_expr)
-
-                    con_expr = f"{_symbol}_min - {corrected_current_point[_symbol]}"
-                    constraints.append(
-                        Constraint(
-                            name=f"improvement constraint for {_symbol}",
-                            symbol=f"{_symbol}_{i+1}_lt",
-                            func=con_expr,
-                            cons_type=ConstraintTypeEnum.LTE,
-                            is_linear=problem.is_linear,
-                            is_convex=problem.is_convex,
-                            is_twice_differentiable=problem.is_twice_differentiable,
-                        )
-                    )
-                case ("<=", aspiration):
-                    # if obj is to be maximized, then the current aspiration value needs to be multiplied by -1
-                    max_expr = (
-                        f"{weights[_symbol]} * ({_symbol}_min - {aspiration * -1 if obj.maximize else aspiration})"
-                    )
-                    max_args.append(max_expr)
-
-                    con_expr = f"{_symbol}_min - {corrected_current_point[_symbol]}"
-                    constraints.append(
-                        Constraint(
-                            name=f"improvement until constraint for {_symbol}",
-                            symbol=f"{_symbol}_{i+1}_lte",
-                            func=con_expr,
-                            cons_type=ConstraintTypeEnum.LTE,
-                            is_linear=problem.is_linear,
-                            is_convex=problem.is_convex,
-                            is_twice_differentiable=problem.is_twice_differentiable,
-                        )
-                    )
-                case ("=", _):
-                    con_expr = f"{_symbol}_min - {corrected_current_point[_symbol]}"
-                    constraints.append(
-                        Constraint(
-                            name=f"Stay at least as good constraint for {_symbol}",
-                            symbol=f"{_symbol}_{i+1}_eq",
-                            func=con_expr,
-                            cons_type=ConstraintTypeEnum.LTE,
-                            is_linear=problem.is_linear,
-                            is_convex=problem.is_convex,
-                            is_twice_differentiable=problem.is_twice_differentiable,
-                        )
-                    )
-                case (">=", reservation):
-                    # if obj is to be maximized, then the current reservation value needs to be multiplied by -1
-                    con_expr = f"{_symbol}_min - {-1 * reservation if obj.maximize else reservation}"
-                    constraints.append(
-                        Constraint(
-                            name=f"Worsen until constraint for {_symbol}",
-                            symbol=f"{_symbol}_{i+1}_gte",
-                            func=con_expr,
-                            cons_type=ConstraintTypeEnum.LTE,
-                            is_linear=problem.is_linear,
-                            is_convex=problem.is_convex,
-                            is_twice_differentiable=problem.is_twice_differentiable,
-                        )
-                    )
-                case ("0", _):
-                    # not relevant for this scalarization
-                    pass
-                case (c, _):
-                    msg = (
-                        f"Warning! The classification {c} was supplied, but it is not supported."
-                        "Must be one of ['<', '<=', '0', '=', '>=']"
-                    )
-    max_expr = f"Max({','.join(max_args)})"
+    # define the auxiliary variable
+    alpha = Variable(
+        name="alpha",
+        symbol="_alpha",
+        variable_type=VariableTypeEnum.real,
+        lowerbound=-float("Inf"),
+        upperbound=float("Inf"),
+        initial_value=1.0,
+    )
 
-    # form the augmentation term
-    aug_exprs = []
-    for _ in range(len(classifications_list)):
-        aug_expr = " + ".join([f"({weights[obj.symbol]} * {obj.symbol}_min)" for obj in problem.objectives])
-        aug_exprs.append(aug_expr)
-    aug_exprs = " + ".join(aug_exprs)
+    # define the objective function of the scalarization
+    aug_expr = " + ".join(
+        [
+            f"{obj.symbol}_min / ({(reference_point[obj.symbol] - ideal_point[obj.symbol]) + delta})"
+            for obj in problem.objectives
+        ]
+    )
 
-    func = f"{max_expr} + {rho} * ({aug_exprs})"
+    target_expr = f"_alpha + {rho}*" + f"({aug_expr})"
     scalarization = ScalarizationFunction(
-        name="NIMBUS scalarization objective function for multiple decision makers",
+        name="STOM scalarization objective function",
         symbol=symbol,
-        func=func,
+        func=target_expr,
+        is_twice_differentiable=problem.is_twice_differentiable,
         is_linear=problem.is_linear,
         is_convex=problem.is_convex,
-        is_twice_differentiable=False,
     )
 
-    _problem = problem.add_scalarization(scalarization)
-    return _problem.add_constraints(constraints), symbol
-
-
-def add_group_nimbus_sf_diff(  # noqa: PLR0913
-    problem: Problem,
-    symbol: str,
-    classifications_list: list[dict[str, tuple[str, float | None]]],
-    current_objective_vector: dict[str, float],
-    ideal: dict[str, float] | None = None,
-    nadir: dict[str, float] | None = None,
-    delta: float = 0.000001,
-    rho: float = 0.000001,
-) -> tuple[Problem, str]:
-    r"""Implements the differentiable variant of the multiple decision maker of the group NIMBUS scalarization function.
-
-    The scalarization function is defined as follows:
-
-    \begin{align}
-        \mbox{minimize} \quad
-         &\alpha +
-        \rho \sum^k_{i=1} \sum^{n_d}_{d=1} w_{id}f_{id}(\mathbf{x})\\
-        \mbox{subject to} \quad & w_{id}(f_{id}(\mathbf{x})-z^{ideal}_{id}) - \alpha \leq 0 \quad & \forall i \in I^<,\\
-        & w_{jd}(f_{jd}(\mathbf{x})-\hat{z}_{jd}) - \alpha \leq 0 \quad & \forall j \in I^\leq ,\\
-        & f_i(\mathbf{x}) - f_i(\mathbf{x_c}) \leq 0 \quad & \forall i \in I^< \cup I^\leq \cup I^= ,\\
-        & f_i(\mathbf{x}) - \epsilon_i \leq 0 \quad & \forall i \in I^\geq ,\\
-        & \mathbf{x} \in \mathbf{X},
-    \end{align}
-
-    where $w_{id} = \frac{1}{z^{nad}_{id} - z^{uto}_{id}}$, and $w_{jd} = \frac{1}{z^{nad}_{jd} - z^{uto}_{jd}}$.
-
-    The $I$-sets are related to the classifications given to each objective function value
-    in respect to  the current objective vector (e.g., by a decision maker). They
-    are as follows:
-
-    - $I^{<}$: values that should improve,
-    - $I^{\leq}$: values that should improve until a given aspiration level $\hat{z}_i$,
-    - $I^{=}$: values that are fine as they are,
-    - $I^{\geq}$: values that can be impaired until some reservation level $\varepsilon_i$, and
-    - $I^{\diamond}$: values that are allowed to change freely (not present explicitly in this scalarization function).
-
-    The aspiration levels and the reservation levels are supplied for each classification, when relevant, in
-    the argument `classifications` as follows:
-
-    ```python
-    classifications = {
-        "f_1": ("<", None),
-        "f_2": ("<=", 42.1),
-        "f_3": (">=", 22.2),
-        "f_4": ("0", None)
-        }
-    ```
-
-    Here, we have assumed four objective functions. The key of the dict is a function's symbol, and the tuple
-    consists of a pair where the left element is the classification (self explanatory, '0' is for objective values
-    that may change freely), the right element is either `None` or an aspiration or a reservation level
-    depending on the classification.
-
-    Args:
-        problem (Problem): the problem to be scalarized.
-        symbol (str): the symbol given to the scalarization function, i.e., target of the optimization.
-        classifications_list (list[dict[str, tuple[str, float  |  None]]]): a list of dicts, where the key is a symbol
-            of an objective function, and the value is a tuple with a classification and an aspiration
-            or a reservation level, or `None`, depending on the classification. See above for an
-            explanation.
-        current_objective_vector (dict[str, float]): the current objective vector that corresponds to
-            a Pareto optimal solution. The classifications are assumed to been given in respect to
-            this vector.
-        ideal (dict[str, float], optional): ideal point values. If not given, attempt will be made
-            to calculate ideal point from problem.
-        nadir (dict[str, float], optional): nadir point values. If not given, attempt will be made
-            to calculate nadir point from problem.
-        delta (float, optional): a small scalar used to define the utopian point. Defaults to 0.000001.
-        rho (float, optional): a small scalar used in the augmentation term. Defaults to 0.000001.
-
-    Raises:
-        ScalarizationError: any of the given classifications do not define a classification
-            for all the objective functions or any of the given classifications do not allow at
-            least one objective function value to improve and one to worsen.
-
-    Returns:
-        tuple[Problem, str]: a tuple with the copy of the problem with the added
-            scalarization and the symbol of the added scalarization.
-    """
-    # check that classifications have been provided for all objective functions
-    for classifications in classifications_list:
-        if not objective_dict_has_all_symbols(problem, classifications):
-            msg = (
-                f"The given classifications {classifications} do not define "
-                "a classification for all the objective functions."
-            )
-            raise ScalarizationError(msg)
-
-        # check that at least one objective function is allowed to be improved and one is
-        # allowed to worsen
-        if not any(classifications[obj.symbol][0] in ["<", "<="] for obj in problem.objectives) or not any(
-            classifications[obj.symbol][0] in [">=", "0"] for obj in problem.objectives
-        ):
-            msg = (
-                f"The given classifications {classifications} should allow at least one objective function value "
-                "to improve and one to worsen."
-            )
-            raise ScalarizationError(msg)
-
-    # check if ideal point is specified
-    # if not specified, try to calculate corrected ideal point
-    if ideal is not None:
-        ideal_point = ideal
-    elif problem.get_ideal_point() is not None:
-        ideal_point = get_corrected_ideal(problem)
-    else:
-        msg = "Ideal point not defined!"
-        raise ScalarizationError(msg)
-
-    # check if nadir point is specified
-    # if not specified, try to calculate corrected nadir point
-    if nadir is not None:
-        nadir_point = nadir
-    elif problem.get_nadir_point() is not None:
-        nadir_point = get_corrected_nadir(problem)
-    else:
-        msg = "Nadir point not defined!"
-        raise ScalarizationError(msg)
-
-    corrected_current_point = get_corrected_reference_point(problem, current_objective_vector)
-
-    # define the auxiliary variable
-    alpha = Variable(
-        name="alpha",
-        symbol="_alpha",
-        variable_type=VariableTypeEnum.real,
-        lowerbound=-float("Inf"),
-        upperbound=float("Inf"),
-        initial_value=1.0,
-    )
-
-    # calculate the weights
-    weights = {
-        obj.symbol: 1 / (nadir_point[obj.symbol] - (ideal_point[obj.symbol] - delta)) for obj in problem.objectives
-    }
-
-    constraints = []
-
-    for i in range(len(classifications_list)):
-        classifications = classifications_list[i]
-        for obj in problem.objectives:
-            _symbol = obj.symbol
-            match classifications[_symbol]:
-                case ("<", _):
-                    max_expr = f"{weights[_symbol]} * ({_symbol}_min - {ideal_point[_symbol]}) - _alpha"
-                    constraints.append(
-                        Constraint(
-                            name=f"Max term linearization for {_symbol}",
-                            symbol=f"max_con_{_symbol}_{i+1}",
-                            func=max_expr,
-                            cons_type=ConstraintTypeEnum.LTE,
-                            is_linear=problem.is_linear,
-                            is_convex=problem.is_convex,
-                            is_twice_differentiable=problem.is_twice_differentiable,
-                        )
-                    )
-                    con_expr = f"{_symbol}_min - {corrected_current_point[_symbol]}"
-                    constraints.append(
-                        Constraint(
-                            name=f"improvement constraint for {_symbol}",
-                            symbol=f"{_symbol}_{i+1}_lt",
-                            func=con_expr,
-                            cons_type=ConstraintTypeEnum.LTE,
-                            is_linear=problem.is_linear,
-                            is_convex=problem.is_convex,
-                            is_twice_differentiable=problem.is_twice_differentiable,
-                        )
-                    )
-                case ("<=", aspiration):
-                    # if obj is to be maximized, then the current aspiration value needs to be multiplied by -1
-                    max_expr = (
-                        f"{weights[_symbol]} * ({_symbol}_min - {aspiration * -1 if obj.maximize else aspiration}) "
-                        "- _alpha"
-                    )
-                    constraints.append(
-                        Constraint(
-                            name=f"Max term linearization for {_symbol}",
-                            symbol=f"max_con_{_symbol}_{i+1}",
-                            func=max_expr,
-                            cons_type=ConstraintTypeEnum.LTE,
-                            is_linear=problem.is_linear,
-                            is_convex=problem.is_convex,
-                            is_twice_differentiable=problem.is_twice_differentiable,
-                        )
-                    )
-                    con_expr = f"{_symbol}_min - {corrected_current_point[_symbol]}"
-                    constraints.append(
-                        Constraint(
-                            name=f"improvement until constraint for {_symbol}",
-                            symbol=f"{_symbol}_{i+1}_lte",
-                            func=con_expr,
-                            cons_type=ConstraintTypeEnum.LTE,
-                            is_linear=problem.is_linear,
-                            is_convex=problem.is_convex,
-                            is_twice_differentiable=problem.is_twice_differentiable,
-                        )
-                    )
-                case ("=", _):
-                    con_expr = f"{_symbol}_min - {corrected_current_point[_symbol]}"
-                    constraints.append(
-                        Constraint(
-                            name=f"Stay at least as good constraint for {_symbol}",
-                            symbol=f"{_symbol}_{i+1}_eq",
-                            func=con_expr,
-                            cons_type=ConstraintTypeEnum.LTE,
-                            is_linear=problem.is_linear,
-                            is_convex=problem.is_convex,
-                            is_twice_differentiable=problem.is_twice_differentiable,
-                        )
-                    )
-                case (">=", reservation):
-                    # if obj is to be maximized, then the current reservation value needs to be multiplied by -1
-                    con_expr = f"{_symbol}_min - {-1 * reservation if obj.maximize else reservation}"
-                    constraints.append(
-                        Constraint(
-                            name=f"Worsen until constraint for {_symbol}",
-                            symbol=f"{_symbol}_{i+1}_gte",
-                            func=con_expr,
-                            cons_type=ConstraintTypeEnum.LTE,
-                            is_linear=problem.is_linear,
-                            is_convex=problem.is_convex,
-                            is_twice_differentiable=problem.is_twice_differentiable,
-                        )
-                    )
-                case ("0", _):
-                    # not relevant for this scalarization
-                    pass
-                case (c, _):
-                    msg = (
-                        f"Warning! The classification {c} was supplied, but it is not supported."
-                        "Must be one of ['<', '<=', '0', '=', '>=']"
-                    )
-
-    # form the augmentation term
-    aug_exprs = []
-    for _ in range(len(classifications_list)):
-        aug_expr = " + ".join([f"({weights[obj.symbol]} * {obj.symbol}_min)" for obj in problem.objectives])
-        aug_exprs.append(aug_expr)
-    aug_exprs = " + ".join(aug_exprs)
-
-    func = f"_alpha + {rho} * ({aug_exprs})"
-    scalarization_function = ScalarizationFunction(
-        name="Differentiable NIMBUS scalarization objective function for multiple decision makers",
-        symbol=symbol,
-        func=func,
-        is_linear=problem.is_linear,
-        is_convex=problem.is_convex,
-        is_twice_differentiable=problem.is_twice_differentiable,
-    )
-    _problem = problem.add_variables([alpha])
-    _problem = _problem.add_scalarization(scalarization_function)
-    return _problem.add_constraints(constraints), symbol
-
-
-def add_stom_sf_diff(
-    problem: Problem,
-    symbol: str,
-    reference_point: dict[str, float],
-    ideal: dict[str, float] | None = None,
-    rho: float = 1e-6,
-    delta: float = 1e-6,
-) -> tuple[Problem, str]:
-    r"""Adds the differentiable variant of the STOM scalarizing function.
-
-    \begin{align*}
-        \min \quad & \alpha + \rho \sum_{i=1}^k \frac{f_i(\mathbf{x})}{\bar{z}_i - z_i^{\star\star}} \\
-        \text{s.t.} \quad & \frac{f_i(\mathbf{x}) - z_i^{\star\star}}{\bar{z}_i
-        - z_i^{\star\star}} - \alpha \leq 0 \quad & \forall i = 1,\dots,k\\
-        & \mathbf{x} \in S,
-    \end{align*}
-
-    where $f_i$ are objective functions, $z_i^{\star\star} = z_i^\star - \delta$ is
-    a component of the utopian point, $\bar{z}_i$ is a component of the reference point,
-    $\rho$ and $\delta$ are small scalar values, $S$ is the feasible solution
-    space of the original problem,  and $\alpha$ is an auxiliary variable.
-
-    References:
-        H. Nakayama, Y. Sawaragi, Satisficing trade-off method for
-            multiobjective programming, in: M. Grauer, A.P. Wierzbicki (Eds.),
-            Interactive Decision Analysis, Springer Verlag, Berlin, 1984, pp.
-            113-122.
-
-    Args:
-        problem (Problem): the problem the scalarization is added to.
-        symbol (str): the symbol given to the added scalarization.
-        reference_point (dict[str, float]): a dict with keys corresponding to objective
-            function symbols and values to reference point components, i.e.,
-            aspiration levels.
-        ideal (dict[str, float], optional): ideal point values. If not given, attempt will be made
-            to calculate ideal point from problem.
-        rho (float, optional): a small scalar value to scale the sum in the objective
-            function of the scalarization. Defaults to 1e-6.
-        delta (float, optional): a small scalar value to define the utopian point. Defaults to 1e-6.
-
-    Returns:
-        tuple[Problem, str]: a tuple with the copy of the problem with the added
-            scalarization and the symbol of the added scalarization.
-    """
-    # check reference point
-    if not objective_dict_has_all_symbols(problem, reference_point):
-        msg = f"The give reference point {reference_point} is missing value for one or more objectives."
-        raise ScalarizationError(msg)
-
-    # check if ideal point is specified
-    # if not specified, try to calculate corrected ideal point
-    if ideal is not None:
-        ideal_point = ideal
-    elif problem.get_ideal_point() is not None:
-        ideal_point = get_corrected_ideal(problem)
-    else:
-        msg = "Ideal point not defined!"
-        raise ScalarizationError(msg)
-
-    corrected_rp = get_corrected_reference_point(problem, reference_point)
-
-    # define the auxiliary variable
-    alpha = Variable(
-        name="alpha",
-        symbol="_alpha",
-        variable_type=VariableTypeEnum.real,
-        lowerbound=-float("Inf"),
-        upperbound=float("Inf"),
-        initial_value=1.0,
-    )
-
-    # define the objective function of the scalarization
-    aug_expr = " + ".join(
-        [
-            f"{obj.symbol}_min / ({reference_point[obj.symbol]} - {ideal_point[obj.symbol] - delta})"
-            for obj in problem.objectives
-        ]
-    )
-
-    target_expr = f"_alpha + {rho}*" + f"({aug_expr})"
-    scalarization = ScalarizationFunction(
-        name="STOM scalarization objective function",
-        symbol=symbol,
-        func=target_expr,
-        is_twice_differentiable=problem.is_twice_differentiable,
-        is_linear=problem.is_linear,
-        is_convex=problem.is_convex,
-    )
-
-    constraints = []
+    constraints = []
 
     for obj in problem.objectives:
         expr = (
             f"({obj.symbol}_min - {ideal_point[obj.symbol] - delta}) / "
-            f"({corrected_rp[obj.symbol] - (ideal_point[obj.symbol] - delta)}) - _alpha"
+            f"({(corrected_rp[obj.symbol] - ideal_point[obj.symbol]) + delta}) - _alpha"
         )
         constraints.append(
             Constraint(
@@ -1857,192 +1154,16 @@ def add_stom_sf_nondiff(
     $\rho$ and $\delta$ are small scalar values, and $S$ is the feasible solution
     space of the original problem.
 
-    References:
-        H. Nakayama, Y. Sawaragi, Satisficing trade-off method for
-            multiobjective programming, in: M. Grauer, A.P. Wierzbicki (Eds.),
-            Interactive Decision Analysis, Springer Verlag, Berlin, 1984, pp.
-            113-122.
-
-    Args:
-        problem (Problem): the problem the scalarization is added to.
-        symbol (str): the symbol given to the added scalarization.
-        reference_point (dict[str, float]): a dict with keys corresponding to objective
-            function symbols and values to reference point components, i.e.,
-            aspiration levels.
-        ideal (dict[str, float], optional): ideal point values. If not given, attempt will be made
-            to calculate ideal point from problem.
-        rho (float, optional): a small scalar value to scale the sum in the objective
-            function of the scalarization. Defaults to 1e-6.
-        delta (float, optional): a small scalar value to define the utopian point. Defaults to 1e-6.
-
-    Returns:
-        tuple[Problem, str]: a tuple with the copy of the problem with the added
-            scalarization and the symbol of the added scalarization.
-    """
-    # check reference point
-    if not objective_dict_has_all_symbols(problem, reference_point):
-        msg = f"The give reference point {reference_point} is missing value for one or more objectives."
-        raise ScalarizationError(msg)
-
-    # check if ideal point is specified
-    # if not specified, try to calculate corrected ideal point
-    if ideal is not None:
-        ideal_point = ideal
-    elif problem.get_ideal_point() is not None:
-        ideal_point = get_corrected_ideal(problem)
-    else:
-        msg = "Ideal point not defined!"
-        raise ScalarizationError(msg)
-
-    corrected_rp = get_corrected_reference_point(problem, reference_point)
-
-    # define the objective function of the scalarization
-    max_expr = ", ".join(
-        [
-            (
-                f"({obj.symbol}_min - {ideal_point[obj.symbol] - delta}) / "
-                f"({corrected_rp[obj.symbol]} - {ideal_point[obj.symbol] - delta})"
-            )
-            for obj in problem.objectives
-        ]
-    )
-    aug_expr = " + ".join(
-        [
-            f"{obj.symbol}_min / ({reference_point[obj.symbol]} - {ideal_point[obj.symbol] - delta})"
-            for obj in problem.objectives
-        ]
-    )
-
-    target_expr = f"{Op.MAX}({max_expr}) + {rho}*" + f"({aug_expr})"
-    scalarization = ScalarizationFunction(
-        name="STOM scalarization objective function",
-        symbol=symbol,
-        func=target_expr,
-        is_linear=False,
-        is_convex=False,
-        is_twice_differentiable=False,
-    )
-
-    return problem.add_scalarization(scalarization), symbol
-
-
-def add_group_stom_sf(
-    problem: Problem,
-    symbol: str,
-    reference_points: list[dict[str, float]],
-    ideal: dict[str, float] | None = None,
-    rho: float = 1e-6,
-    delta: float = 1e-6,
-) -> tuple[Problem, str]:
-    r"""Adds the multiple decision maker variant of the STOM scalarizing function.
-
-    The scalarization function is defined as follows:
-
-    \begin{align}
-        &\mbox{minimize} &&\max_{i,d} [w_{id}(f_{id}(\mathbf{x})-z^{uto}_{id})] +
-        \rho \sum^k_{i=1} \sum^{n_d}_{d=1} w_{id}f_{id}(\mathbf{x}) \\
-        &\mbox{subject to} &&\mathbf{x} \in \mathbf{X},
-    \end{align}
-
-    where $w_{id} = \frac{1}{\overline{z}_{id} - z^{uto}_{id}}$.
-
-    Args:
-        problem (Problem): the problem the scalarization is added to.
-        symbol (str): the symbol given to the added scalarization.
-        reference_points (list[dict[str, float]]): a list of dicts with keys corresponding to objective
-            function symbols and values to reference point components, i.e.,
-            aspiration levels.
-        ideal (dict[str, float], optional): ideal point values. If not given, attempt will be made
-            to calculate ideal point from problem.
-        rho (float, optional): a small scalar value to scale the sum in the objective
-            function of the scalarization. Defaults to 1e-6.
-        delta (float, optional): a small scalar value to define the utopian point. Defaults to 1e-6.
-
-    Raises:
-        ScalarizationError: there are missing elements in any reference point.
-
-    Returns:
-        tuple[Problem, str]: a tuple with the copy of the problem with the added
-            scalarization and the symbol of the added scalarization.
-    """
-    # check reference points
-    for reference_point in reference_points:
-        if not objective_dict_has_all_symbols(problem, reference_point):
-            msg = f"The give reference point {reference_point} is missing value for one or more objectives."
-            raise ScalarizationError(msg)
-
-    # check if ideal point is specified
-    # if not specified, try to calculate corrected ideal point
-    if ideal is not None:
-        ideal_point = ideal
-    elif problem.get_ideal_point() is not None:
-        ideal_point = get_corrected_ideal(problem)
-    else:
-        msg = "Ideal point not defined!"
-        raise ScalarizationError(msg)
-
-    # calculate the weights
-    weights = []
-    for reference_point in reference_points:
-        corrected_rp = get_corrected_reference_point(problem, reference_point)
-        weights.append(
-            {
-                obj.symbol: 1 / (corrected_rp[obj.symbol] - (ideal_point[obj.symbol] - delta))
-                for obj in problem.objectives
-            }
-        )
-
-    # form the max term
-    max_terms = []
-    for i in range(len(reference_points)):
-        for obj in problem.objectives:
-            max_terms.append(f"{weights[i][obj.symbol]} * ({obj.symbol}_min - {ideal_point[obj.symbol] - delta})")
-    max_terms = ", ".join(max_terms)
-
-    # form the augmentation term
-    aug_exprs = []
-    for i in range(len(reference_points)):
-        aug_expr = " + ".join([f"({weights[i][obj.symbol]} * {obj.symbol}_min)" for obj in problem.objectives])
-        aug_exprs.append(aug_expr)
-    aug_exprs = " + ".join(aug_exprs)
-
-    func = f"{Op.MAX}({max_terms}) + {rho}*({aug_exprs})"
-    scalarization = ScalarizationFunction(
-        name="STOM scalarization objective function for multiple decision makers",
-        symbol=symbol,
-        func=func,
-        is_linear=problem.is_linear,
-        is_convex=problem.is_convex,
-        is_twice_differentiable=False,
-    )
-    return problem.add_scalarization(scalarization), symbol
-
-
-def add_group_stom_sf_diff(
-    problem: Problem,
-    symbol: str,
-    reference_points: list[dict[str, float]],
-    ideal: dict[str, float] | None = None,
-    rho: float = 1e-6,
-    delta: float = 1e-6,
-) -> tuple[Problem, str]:
-    r"""Adds the differentiable variant of the multiple decision maker variant of the STOM scalarizing function.
-
-    The scalarization function is defined as follows:
-
-    \begin{align}
-        &\mbox{minimize} && \alpha +
-        \rho \sum^k_{i=1} \sum^{n_d}_{d=1} w_{id}f_{id}(\mathbf{x}) \\
-        &\mbox{subject to} && w_{id}(f_{id}(\mathbf{x})-z^{uto}_{id}) - \alpha \leq 0,\\
-        &&&\mathbf{x} \in \mathbf{X},
-    \end{align}
-
-    where $w_{id} = \frac{1}{\overline{z}_{id} - z^{uto}_{id}}$.
+    References:
+        H. Nakayama, Y. Sawaragi, Satisficing trade-off method for
+            multiobjective programming, in: M. Grauer, A.P. Wierzbicki (Eds.),
+            Interactive Decision Analysis, Springer Verlag, Berlin, 1984, pp.
+            113-122.
 
     Args:
         problem (Problem): the problem the scalarization is added to.
         symbol (str): the symbol given to the added scalarization.
-        reference_points (list[dict[str, float]]): a list of dicts with keys corresponding to objective
+        reference_point (dict[str, float]): a dict with keys corresponding to objective
             function symbols and values to reference point components, i.e.,
             aspiration levels.
         ideal (dict[str, float], optional): ideal point values. If not given, attempt will be made
@@ -2051,18 +1172,14 @@ def add_group_stom_sf_diff(
             function of the scalarization. Defaults to 1e-6.
         delta (float, optional): a small scalar value to define the utopian point. Defaults to 1e-6.
 
-    Raises:
-        ScalarizationError: there are missing elements in any reference point.
-
     Returns:
         tuple[Problem, str]: a tuple with the copy of the problem with the added
             scalarization and the symbol of the added scalarization.
     """
-    # check reference points
-    for reference_point in reference_points:
-        if not objective_dict_has_all_symbols(problem, reference_point):
-            msg = f"The give reference point {reference_point} is missing value for one or more objectives."
-            raise ScalarizationError(msg)
+    # check reference point
+    if not objective_dict_has_all_symbols(problem, reference_point):
+        msg = f"The give reference point {reference_point} is missing value for one or more objectives."
+        raise ScalarizationError(msg)
 
     # check if ideal point is specified
     # if not specified, try to calculate corrected ideal point
@@ -2074,75 +1191,36 @@ def add_group_stom_sf_diff(
         msg = "Ideal point not defined!"
         raise ScalarizationError(msg)
 
-    # define the auxiliary variable
-    alpha = Variable(
-        name="alpha",
-        symbol="_alpha",
-        variable_type=VariableTypeEnum.real,
-        lowerbound=-float("Inf"),
-        upperbound=float("Inf"),
-        initial_value=1.0,
-    )
-
-    # calculate the weights
-    weights = []
-    for reference_point in reference_points:
-        corrected_rp = get_corrected_reference_point(problem, reference_point)
-        weights.append(
-            {
-                obj.symbol: 1 / (corrected_rp[obj.symbol] - (ideal_point[obj.symbol] - delta))
-                for obj in problem.objectives
-            }
-        )
-
-    # form the max term
-    con_terms = []
-    for i in range(len(reference_points)):
-        rp = {}
-        for obj in problem.objectives:
-            rp[obj.symbol] = (
-                f"{weights[i][obj.symbol]} * ({obj.symbol}_min - {ideal_point[obj.symbol] - delta}) - _alpha"
-            )
-        con_terms.append(rp)
-
-    # form the augmentation term
-    aug_exprs = []
-    for i in range(len(reference_points)):
-        aug_expr = " + ".join([f"({weights[i][obj.symbol]} * {obj.symbol}_min)" for obj in problem.objectives])
-        aug_exprs.append(aug_expr)
-    aug_exprs = " + ".join(aug_exprs)
+    corrected_rp = flip_maximized_objective_values(problem, reference_point)
 
-    constraints = []
-    # loop to create a constraint for every objective of every reference point given
-    for i in range(len(reference_points)):
-        for obj in problem.objectives:
-            # since we are subtracting a constant value, the linearity, convexity,
-            # and differentiability of the objective function, and hence the
-            # constraint, should not change.
-            constraints.append(
-                Constraint(
-                    name=f"Constraint for {obj.symbol}",
-                    symbol=f"{obj.symbol}_con_{i+1}",
-                    func=con_terms[i][obj.symbol],
-                    cons_type=ConstraintTypeEnum.LTE,
-                    is_linear=obj.is_linear,
-                    is_convex=obj.is_convex,
-                    is_twice_differentiable=obj.is_twice_differentiable,
-                )
+    # define the objective function of the scalarization
+    max_expr = ", ".join(
+        [
+            (
+                f"({obj.symbol}_min - {ideal_point[obj.symbol] - delta}) / "
+                f"({(corrected_rp[obj.symbol] - ideal_point[obj.symbol]) + delta})"
             )
+            for obj in problem.objectives
+        ]
+    )
+    aug_expr = " + ".join(
+        [
+            f"{obj.symbol}_min / ({(reference_point[obj.symbol] - ideal_point[obj.symbol]) + delta})"
+            for obj in problem.objectives
+        ]
+    )
 
-    func = f"_alpha + {rho}*({aug_exprs})"
+    target_expr = f"{Op.MAX}({max_expr}) + {rho}*" + f"({aug_expr})"
     scalarization = ScalarizationFunction(
-        name="Differentiable STOM scalarization objective function for multiple decision makers",
+        name="STOM scalarization objective function",
         symbol=symbol,
-        func=func,
-        is_linear=problem.is_linear,
-        is_convex=problem.is_convex,
-        is_twice_differentiable=problem.is_twice_differentiable,
+        func=target_expr,
+        is_linear=False,
+        is_convex=False,
+        is_twice_differentiable=False,
     )
-    _problem = problem.add_variables([alpha])
-    _problem = _problem.add_scalarization(scalarization)
-    return _problem.add_constraints(constraints), symbol
+
+    return problem.add_scalarization(scalarization), symbol
 
 
 def add_guess_sf_diff(
@@ -2157,29 +1235,33 @@ def add_guess_sf_diff(
     r"""Adds the differentiable variant of the GUESS scalarizing function.
 
     \begin{align*}
-        \min \quad & \alpha + \rho \sum_{i=1}^k \frac{f_i(\mathbf{x})}{d_i} \\
-        \text{s.t.} \quad & \frac{f_i(\mathbf{x}) - z_i^{\star\star}}{\bar{z}_i
-        - z_i^{\star\star}} - \alpha \leq 0 \quad & \forall i \notin I^{\diamond},\\
-        & d_i =
-        \begin{cases}
-        z^\text{nad}_i - \bar{z}_i,\quad \forall i \notin I^\diamond,\\
-        z^\text{nad}_i - z^{\star\star}_i,\quad \forall i \in I^\diamond,\\
-        \end{cases}\\
+        \min \quad & \alpha + \rho \sum_{i=1}^k \frac{f_i(\mathbf{x})}{z_i^{nad} - \bar{z}_i},
+        \quad & \\
+        \text{s.t.} \quad & \frac{f_i(\mathbf{x}) - z_i^{nad}}{z_i^{nad} - \bar{z}_i}
+         - \alpha \leq 0 \quad & \forall i \notin I^{\diamond},\\
         & \mathbf{x} \in S,
     \end{align*}
 
-    where $f_i$ are objective functions, $z_i^{\star\star} = z_i^\star - \delta$ is
-    a component of the utopian point, $\bar{z}_i$ is a component of the reference point,
-    $\rho$ and $\delta$ are small scalar values, $S$ is the feasible solution
-    space of the original problem, and $\alpha$ is an auxiliary variable. The index
-    set $I^\diamond$ represents objective vectors whose values are free to change. The indices
-    belonging to this set are interpreted as those objective vectors whose components in
-    the reference point is set to be the the respective nadir point component of the problem.
+    where $f_{i}$ are objective functions, $z_{i}^{nad}$ is a component of the
+    nadir point, $\bar{z}_{i}$
+    is a component of the reference point, $\rho$ is a small scalar
+    value, and $S$ is the feasible solution space of the original problem. The
+    index set $I^\diamond$ represents objective vectors whose values are free to
+    change. The indices belonging to this set are interpreted as those objective
+    vectors whose components in the reference point is set to be the the
+    respective nadir point component of the problem. Note that in Buchanan (1997),
+    the GUESS method considers all objective functions, i.e. $I^\diamond$ is
+    an empty set. The functionality to have free-to-change objectives was added
+    in Miettinen & Mäkelä (2006).
 
     References:
         Buchanan, J. T. (1997). A naive approach for solving MCDM problems: The
         GUESS method. Journal of the Operational Research Society, 48, 202-206.
 
+        Miettinen, K., & Mäkelä, M. M. (2006). Synchronous approach in interactive
+        multiobjective optimization. European Journal of Operational Research,
+        170(3), 909-922.
+
     Args:
         problem (Problem): the problem the scalarization is added to.
         symbol (str): the symbol given to the added scalarization.
@@ -2192,7 +1274,7 @@ def add_guess_sf_diff(
             to calculate nadir point from problem.
         rho (float, optional): a small scalar value to scale the sum in the objective
             function of the scalarization. Defaults to 1e-6.
-        delta (float, optional): a small scalar to define the utopian point. Defaults to 1e-6.
+        delta (float, optional): a small scalar value to define the utopian point. Defaults to 1e-6.
 
     Returns:
         tuple[Problem, str]: a tuple with the copy of the problem with the added
@@ -2223,7 +1305,7 @@ def add_guess_sf_diff(
         msg = "Nadir point not defined!"
         raise ScalarizationError(msg)
 
-    corrected_rp = get_corrected_reference_point(problem, reference_point)
+    corrected_rp = flip_maximized_objective_values(problem, reference_point)
 
     # the indices that are free to change, set if component of reference point
     # has the corresponding nadir value, or if it is greater than the nadir value
@@ -2246,9 +1328,10 @@ def add_guess_sf_diff(
     # define the objective function of the scalarization
     aug_expr = " + ".join(
         [
-            (
-                f"{obj.symbol}_min / ({nadir_point[obj.symbol]} - "
-                f"{reference_point[obj.symbol] if obj.symbol not in free_to_change else ideal_point[obj.symbol] - delta})"  # noqa: E501
+            (  # Technically delta should be included (according to the paper), but I'm a rebel and don't want to add it
+                f"{obj.symbol}_min / ({nadir_point[obj.symbol]} - {ideal_point[obj.symbol]})"
+                if obj.symbol in free_to_change
+                else f"{obj.symbol}_min / ({nadir_point[obj.symbol]} - {corrected_rp[obj.symbol]})"
             )
             for obj in problem.objectives
         ]
@@ -2301,39 +1384,40 @@ def add_guess_sf_nondiff(
     ideal: dict[str, float] | None = None,
     nadir: dict[str, float] | None = None,
     rho: float = 1e-6,
-    delta: float = 1e-6,
 ) -> tuple[Problem, str]:
     r"""Adds the non-differentiable variant of the GUESS scalarizing function.
 
     \begin{align*}
         \underset{\mathbf{x}}{\min}\quad & \underset{i \notin I^\diamond}{\max}
         \left[
-        \frac{f_i(\mathbf{x}) - z_i^{\star\star}}{\bar{z}_i - z_i^{\star\star}}
+        \frac{f_i(\mathbf{x}) - z_i^{nad}}{z_i^{nad} - \bar{z}_i}
         \right]
-        + \rho \sum_{j=1}^k \frac{f_j(\mathbf{x})}{d_j},
+        + \rho \sum_{i=1}^k \frac{f_i(\mathbf{x})}{z_i^{nad} - \bar{z}_i},
         \quad & \\
         \text{s.t.}\quad
-        & d_j =
-        \begin{cases}
-        z^\text{nad}_j - \bar{z}_j,\quad \forall j \notin I^\diamond,\\
-        z^\text{nad}_j - z^{\star\star}_j,\quad \forall j \in I^\diamond,\\
-        \end{cases}\\
         & \mathbf{x} \in S,
     \end{align*}
 
-    where $f_{i/j}$ are objective functions, $z_{i/j}^{\star\star} =
-    z_{i/j}^\star - \delta$ is a component of the utopian point, $\bar{z}_{i/j}$
-    is a component of the reference point, $\rho$ and $\delta$ are small scalar
-    values, and $S$ is the feasible solution space of the original problem. The
+    where $f_{i}$ are objective functions, $z_{i}^{nad}$ is a component of the
+    nadir point, $\bar{z}_{i}$
+    is a component of the reference point, $\rho$ is a small scalar
+    value, and $S$ is the feasible solution space of the original problem. The
     index set $I^\diamond$ represents objective vectors whose values are free to
     change. The indices belonging to this set are interpreted as those objective
     vectors whose components in the reference point is set to be the the
-    respective nadir point component of the problem.
+    respective nadir point component of the problem. Note that in Buchanan (1997),
+    the GUESS method considers all objective functions, i.e. $I^\diamond$ is
+    an empty set. The functionality to have free-to-change objectives was added
+    in Miettinen & Mäkelä (2006).
 
     References:
         Buchanan, J. T. (1997). A naive approach for solving MCDM problems: The
         GUESS method. Journal of the Operational Research Society, 48, 202-206.
 
+        Miettinen, K., & Mäkelä, M. M. (2006). Synchronous approach in interactive
+        multiobjective optimization. European Journal of Operational Research,
+        170(3), 909-922.
+
     Args:
         problem (Problem): the problem the scalarization is added to.
         symbol (str): the symbol given to the added scalarization.
@@ -2377,7 +1461,7 @@ def add_guess_sf_nondiff(
         msg = "Nadir point not defined!"
         raise ScalarizationError(msg)
 
-    corrected_rp = get_corrected_reference_point(problem, reference_point)
+    corrected_rp = flip_maximized_objective_values(problem, reference_point)
 
     # the indices that are free to change, set if component of reference point
     # has the corresponding nadir value, or if it is greater than the nadir value
@@ -2393,8 +1477,8 @@ def add_guess_sf_nondiff(
     max_expr = ", ".join(
         [
             (
-                f"({obj.symbol}_min - {(ideal_point[obj.symbol] - delta)}) / "
-                f"({reference_point[obj.symbol]} - {(ideal_point[obj.symbol] - delta)})"
+                f"({obj.symbol}_min - {(nadir_point[obj.symbol])}) / "
+                f"({nadir_point[obj.symbol]} - {(corrected_rp[obj.symbol])})"
             )
             for obj in problem.objectives
             if obj.symbol not in free_to_change
@@ -2404,9 +1488,10 @@ def add_guess_sf_nondiff(
     # define the augmentation term
     aug_expr = " + ".join(
         [
-            (
-                f"{obj.symbol}_min / ({nadir_point[obj.symbol]} - "
-                f"{reference_point[obj.symbol] if obj.symbol not in free_to_change else ideal_point[obj.symbol] - delta})"  # noqa: E501
+            (  # Technically delta should be included (according to the paper), but I'm a rebel and don't want to add it
+                f"{obj.symbol}_min / ({nadir_point[obj.symbol]} - {ideal_point[obj.symbol]})"
+                if obj.symbol in free_to_change
+                else f"{obj.symbol}_min / ({nadir_point[obj.symbol]} - {corrected_rp[obj.symbol]})"
             )
             for obj in problem.objectives
         ]
@@ -2425,225 +1510,6 @@ def add_guess_sf_nondiff(
     return problem.add_scalarization(scalarization), symbol
 
 
-def add_group_guess_sf(
-    problem: Problem,
-    symbol: str,
-    reference_points: list[dict[str, float]],
-    nadir: dict[str, float] | None = None,
-    rho: float = 1e-6,
-    delta: float = 1e-6,
-) -> tuple[Problem, str]:
-    r"""Adds the non-differentiable variant of the multiple decision maker variant of the GUESS scalarizing function.
-
-    The scalarization function is defined as follows:
-
-    \begin{align}
-        &\mbox{minimize} &&\max_{i,d} [w_{id}(f_{id}(\mathbf{x})-z^{nad}_{id})] +
-        \rho \sum^k_{i=1} \sum^{n_d}_{d=1} w_{id}f_{id}(\mathbf{x}) \\
-        &\mbox{subject to} &&\mathbf{x} \in \mathbf{X},
-    \end{align}
-
-    where $w_{id} = \frac{1}{z^{nad}_{id} - \overline{z}_{id}}$.
-
-    Args:
-        problem (Problem): the problem the scalarization is added to.
-        symbol (str): the symbol given to the added scalarization.
-        reference_points (list[dict[str, float]]): a list of dicts with keys corresponding to objective
-            function symbols and values to reference point components, i.e.,
-            aspiration levels.
-        nadir (dict[str, float], optional): nadir point values. If not given, attempt will be made
-            to calculate nadir point from problem.
-        rho (float, optional): a small scalar value to scale the sum in the objective
-            function of the scalarization. Defaults to 1e-6.
-        delta (float, optional): a small scalar to define the utopian point. Defaults to 1e-6.
-
-    Raises:
-        ScalarizationError: there are missing elements in any reference point.
-
-    Returns:
-        tuple[Problem, str]: a tuple with the copy of the problem with the added
-            scalarization and the symbol of the added scalarization.
-    """
-    # check reference points
-    for reference_point in reference_points:
-        if not objective_dict_has_all_symbols(problem, reference_point):
-            msg = f"The give reference point {reference_point} is missing value for one or more objectives."
-            raise ScalarizationError(msg)
-
-    # check if nadir point is specified
-    # if not specified, try to calculate corrected nadir point
-    if nadir is not None:
-        nadir_point = nadir
-    elif problem.get_nadir_point() is not None:
-        nadir_point = get_corrected_nadir(problem)
-    else:
-        msg = "Nadir point not defined!"
-        raise ScalarizationError(msg)
-
-    # calculate the weights
-    weights = []
-    for reference_point in reference_points:
-        corrected_rp = get_corrected_reference_point(problem, reference_point)
-        weights.append(
-            {
-                obj.symbol: 1 / ((nadir_point[obj.symbol] + delta) - (corrected_rp[obj.symbol]))
-                for obj in problem.objectives
-            }
-        )
-
-    # form the max term
-    max_terms = []
-    for i in range(len(reference_points)):
-        corrected_rp = get_corrected_reference_point(problem, reference_points[i])
-        for obj in problem.objectives:
-            max_terms.append(f"{weights[i][obj.symbol]} * ({obj.symbol}_min - {nadir_point[obj.symbol]})")
-    max_terms = ", ".join(max_terms)
-
-    # form the augmentation term
-    aug_exprs = []
-    for i in range(len(reference_points)):
-        aug_expr = " + ".join([f"({weights[i][obj.symbol]} * {obj.symbol}_min)" for obj in problem.objectives])
-        aug_exprs.append(aug_expr)
-    aug_exprs = " + ".join(aug_exprs)
-
-    func = f"{Op.MAX}({max_terms}) + {rho}*({aug_exprs})"
-    scalarization = ScalarizationFunction(
-        name="GUESS scalarization objective function for multiple decision makers",
-        symbol=symbol,
-        func=func,
-        is_linear=problem.is_linear,
-        is_convex=problem.is_convex,
-        is_twice_differentiable=False,
-    )
-    return problem.add_scalarization(scalarization), symbol
-
-
-def add_group_guess_sf_diff(
-    problem: Problem,
-    symbol: str,
-    reference_points: list[dict[str, float]],
-    nadir: dict[str, float] | None = None,
-    rho: float = 1e-6,
-    delta: float = 1e-6,
-) -> tuple[Problem, str]:
-    r"""Adds the differentiable variant of the multiple decision maker variant of the GUESS scalarizing function.
-
-    The scalarization function is defined as follows:
-
-    \begin{align}
-        &\mbox{minimize} &&\alpha +
-        \rho \sum^k_{i=1} \sum^{n_d}_{d=1} w_{id}f_{id}(\mathbf{x}) \\
-        &\mbox{subject to} && w_{id}(f_{id}(\mathbf{x})-z^{nad}_{id}) - \alpha \leq 0,\\
-        &&&\mathbf{x} \in \mathbf{X},
-    \end{align}
-
-    where $w_{id} = \frac{1}{z^{nad}_{id} - \overline{z}_{id}}$.
-
-    Args:
-        problem (Problem): the problem the scalarization is added to.
-        symbol (str): the symbol given to the added scalarization.
-        reference_points (list[dict[str, float]]): a list of dicts with keys corresponding to objective
-            function symbols and values to reference point components, i.e.,
-            aspiration levels.
-        nadir (dict[str, float], optional): nadir point values. If not given, attempt will be made
-            to calculate nadir point from problem.
-        rho (float, optional): a small scalar value to scale the sum in the objective
-            function of the scalarization. Defaults to 1e-6.
-        delta (float, optional): a small scalar to define the utopian point. Defaults to 1e-6.
-
-    Raises:
-        ScalarizationError: there are missing elements in any reference point.
-
-    Returns:
-        tuple[Problem, str]: a tuple with the copy of the problem with the added
-            scalarization and the symbol of the added scalarization.
-    """
-    # check reference points
-    for reference_point in reference_points:
-        if not objective_dict_has_all_symbols(problem, reference_point):
-            msg = f"The give reference point {reference_point} is missing value for one or more objectives."
-            raise ScalarizationError(msg)
-
-    # check if nadir point is specified
-    # if not specified, try to calculate corrected nadir point
-    if nadir is not None:
-        nadir_point = nadir
-    elif problem.get_nadir_point() is not None:
-        nadir_point = get_corrected_nadir(problem)
-    else:
-        msg = "Nadir point not defined!"
-        raise ScalarizationError(msg)
-
-    # define the auxiliary variable
-    alpha = Variable(
-        name="alpha",
-        symbol="_alpha",
-        variable_type=VariableTypeEnum.real,
-        lowerbound=-float("Inf"),
-        upperbound=float("Inf"),
-        initial_value=1.0,
-    )
-
-    # calculate the weights
-    weights = []
-    for reference_point in reference_points:
-        corrected_rp = get_corrected_reference_point(problem, reference_point)
-        weights.append(
-            {
-                obj.symbol: 1 / ((nadir_point[obj.symbol] + delta) - (corrected_rp[obj.symbol]))
-                for obj in problem.objectives
-            }
-        )
-
-    # form the max term
-    con_terms = []
-    for i in range(len(reference_points)):
-        corrected_rp = get_corrected_reference_point(problem, reference_points[i])
-        rp = {}
-        for obj in problem.objectives:
-            rp[obj.symbol] = f"{weights[i][obj.symbol]} * ({obj.symbol}_min - {nadir_point[obj.symbol]}) - _alpha"
-        con_terms.append(rp)
-
-    # form the augmentation term
-    aug_exprs = []
-    for i in range(len(reference_points)):
-        aug_expr = " + ".join([f"({weights[i][obj.symbol]} * {obj.symbol}_min)" for obj in problem.objectives])
-        aug_exprs.append(aug_expr)
-    aug_exprs = " + ".join(aug_exprs)
-
-    constraints = []
-    # loop to create a constraint for every objective of every reference point given
-    for i in range(len(reference_points)):
-        for obj in problem.objectives:
-            # since we are subtracting a constant value, the linearity, convexity,
-            # and differentiability of the objective function, and hence the
-            # constraint, should not change.
-            constraints.append(
-                Constraint(
-                    name=f"Constraint for {obj.symbol}",
-                    symbol=f"{obj.symbol}_con_{i+1}",
-                    func=con_terms[i][obj.symbol],
-                    cons_type=ConstraintTypeEnum.LTE,
-                    is_linear=obj.is_linear,
-                    is_convex=obj.is_convex,
-                    is_twice_differentiable=obj.is_twice_differentiable,
-                )
-            )
-
-    func = f"_alpha + {rho}*({aug_exprs})"
-    scalarization = ScalarizationFunction(
-        name="Differentiable GUESS scalarization objective function for multiple decision makers",
-        symbol=symbol,
-        func=func,
-        is_linear=problem.is_linear,
-        is_convex=problem.is_convex,
-        is_twice_differentiable=problem.is_twice_differentiable,
-    )
-    _problem = problem.add_variables([alpha])
-    _problem = _problem.add_scalarization(scalarization)
-    return _problem.add_constraints(constraints), symbol
-
-
 def add_asf_diff(
     problem: Problem,
     symbol: str,
@@ -2717,7 +1583,7 @@ def add_asf_diff(
         msg = "Nadir point not defined!"
         raise ScalarizationError(msg)
 
-    corrected_rp = get_corrected_reference_point(problem, reference_point)
+    corrected_rp = flip_maximized_objective_values(problem, reference_point)
 
     # define the auxiliary variable
     alpha = Variable(
@@ -2979,160 +1845,221 @@ def create_epsilon_constraints_json(
     return scalarization_expr, constraint_exprs
 
 
-def add_group_scenario_sf_nondiff(
-    problem: Problem,
-    symbol: str,
-    reference_points: list[dict[str, float]],
-    weights: list[dict[str, float]],
-    epsilon: float = 1e-6,
-) -> tuple[Problem, str]:
-    r"""Add the non-differentiable scenario based scalarization function.
+def __create_HDF(
+    y: str,
+    a: float,
+    r: float,
+    d1: float = 0.9,
+    d2: float = 0.1,
+) -> str:
+    r"""Create a Harrington's one-sided desirability function.
 
-    Add the following scalarization function:
-    \begin{align}
-      \min_{\mathbf{x}}\quad
-        &\max_{i,p}\bigl[w_{ip}\bigl(f_{ip}(\mathbf{x}) - \bar z_{ip}\bigr)\bigr]
-        \;+\;\varepsilon \sum_{i,p} w_{ip}\bigl(f_{ip}(\mathbf{x}) - \bar z_{ip}\bigr) \\[6pt]
-      \text{s.t.}\quad
-        &\mathbf{x} \in \mathcal{X}\,,
-    \end{align}
+    Harrington's desirability function is used to compute the desirability of a
+    given value of an objective function based on its aspiration and reservation levels.
 
-    Args:
-        problem (Problem): the problem the scalarization is added to.
-        symbol (str): the symbol given to the added scalarization.
-        reference_points (list[dict[str, float]]): a list of reference points as objective dicts.
-            function symbols and values to reference point components, i.e., aspiration levels.
-        weights (list[dict[str, float]]): the list of weights to be used in the scalarization function.
-            Must be positive.
-        epsilon: small augmentation multiplier ε
+    The desirability function is defined as follows:
+    \begin{equation}
+        D(y) = \exp\left(-\exp\left(-b_0 - b_1 y\right)\right),
+    \end{equation}
 
-    Returns:
-        tuple[Problem, str]: A tuple containing a copy of the problem with the scalarization function added,
-            and the symbol of the added scalarization function.
+    where
+    \begin{align*}
+        b_0 &= -\log(-\log(d_1)) - b_1 a, \\
+        b_1 &= \frac{\log(-\log(d_2)) - \log(-\log(d_1))}{r - a}.
+    \end{align*}
+
+    The desirability function returns a value between 0 and 1, where higher values indicate
+    more desirable outcomes. I took the equations from the following source:
+    Wagner, T., and Trautmann, H. Integration of preference in hypervolume-based
+    multiobjective evolutionary algorithms by means of desirability functions.
+    IEEE Transactions on Evolutionary Computation 14, 5 (2010), 688-701.
+
+    Args:
+        y (str): The objective value to compute the desirability for.
+        a (float): Aspiration level for the objective.
+        r (float): Reservation level for the objective.
+        d1 (float): The desirability for the aspiration level.
+        d2 (float): The desirability for the reservation level.
+
+    Returns: 
+        callable (Function): A function that computes the desirability for a given value.
     """
-    if len(reference_points) != len(weights):
-        raise ScalarizationError("reference_points and weights must have same length")
+    if not (0 < d1 < 1 and 0 < d2 < 1):
+        raise ValueError("Desirability values must be between 0 and 1 (exclusive).")
+    if not (a < r):
+        raise ValueError("a must be less than r.")
+    if not d2 < d1:
+        raise ValueError("d2 must be less than d1. Higher desirability should correspond to lower values of y.")
+    b1: float = -np.log(-np.log(d2)) + np.log(-np.log(d1)) / (r - a)
+    b0: float = -np.log(-np.log(d1)) - b1 * a
 
-    for reference_point, weight in zip(reference_points, weights, strict=True):
-        if not objective_dict_has_all_symbols(problem, reference_point):
-            raise ScalarizationError(
-                f"The give reference point {reference_point} " f"is missing value for one or more objectives."
-            )
-        if not objective_dict_has_all_symbols(problem, weight):
-            raise ScalarizationError(
-                f"The given weight vector {weight} is missing " f"a value for one or more objectives."
-            )
+    def __HDF(y: float):
+        """Compute the desirability for a given value."""
+        return np.exp(-np.exp(-(b0 + b1 * y)))
 
-    max_list: list[str] = []
-    sum_list: list[str] = []
-    for reference_point, weight in zip(reference_points, weights, strict=True):
-        corrected_ref_point = get_corrected_reference_point(problem, reference_point)
+    func = f"Exp(-Exp(-({b0} + {b1} * {y})))"
+    return func
 
-        for obj in problem.objectives:
-            expr = f"{weight[obj.symbol]}*({obj.symbol}_min - {corrected_ref_point[obj.symbol]})"
-            max_list.append(expr)
-            sum_list.append(expr)
 
-    max_part = f"{Op.MAX}({', '.join(max_list)})"
-    sum_part = " + ".join(sum_list)
-    func = f"{max_part} + {epsilon}*({sum_part})"
+def __create_MDF(y: str, a: float, r: float, d1: float = 0.9, d2: float = 0.1) -> str:
+    """Create MaoMao's desirability function.
 
-    scalar = ScalarizationFunction(
-        name="Group non differentiable scalarization function for scenario based problems.",
-        symbol=symbol,
-        func=func,
-        is_linear=problem.is_linear,
-        is_convex=problem.is_convex,
-        is_twice_differentiable=problem.is_twice_differentiable,
+    Distinctions form MaoMao's original function:
+    - The upper and lower bounds of desirability are fixed to 0 and 1, respectively.
+
+    Args:
+        y (str): The objective value to compute the desirability for.
+        a (float): Aspiration level for the objective.
+        r (float): Reservation level for the objective.
+        d1 (float): The desirability for the aspiration level.
+        d2 (float): The desirability for the reservation level.
+
+    Returns: 
+        callable (Function): A function that computes the desirability for a given value.
+    """
+    if not (0 < d1 < 1 and 0 < d2 < 1):
+        raise ValueError("Desirability values must be between 0 and 1 (exclusive).")
+    if not (a < r):
+        raise ValueError("a must be less than r.")
+    if not d2 < d1:
+        raise ValueError("d2 must be less than d1. Higher desirability should correspond to lower values of y.")
+    ea = 1 - d1
+    er = d2
+    m1 = -ea * ea * (a - r) / (d1 - d2)
+    b1 = -a + ea * (a - r) / (d1 - d2)
+    m2 = (d1 - d2) / (a - r)
+    b2 = (d2 * a - d1 * r) / (a - r)
+    m3 = -er * er * (a - r) / (d1 - d2)
+    b3 = -r - er * (a - r) / (d1 - d2)
+
+    def MDF1(y):
+        """Compute the desirability for a given value."""
+        if isinstance(y, np.ndarray):
+            return np.array([MDF1(yi) for yi in y])
+        if y < a:
+            return 1 + m1 / (y + b1)
+        elif a <= y <= r:
+            return m2 * y + b2
+        else:
+            return m3 / (y + b3)
+
+    def MDF(y):
+        """Compute the desirability for a given value."""
+        # Same but without the if statements
+        if isinstance(y, np.ndarray):
+            return np.array([MDF(yi) for yi in y])
+        return (
+            max(a - y, 0) * (1 + m1 / (y + b1)) / (a - y)
+            + max(y - r, 0) * (m3 / (y + b3)) / (y - r)
+            + max(y - a, 0) * max(r - y, 0) * (m2 * y + b2) / ((y - a) * (r - y))
+        )
+
+    func = (
+        f"Max({a} - {y}, 0) * (1 + {m1} / ({y} + {b1})) / ({a} - {y}) + "
+        f"Max({y} - {r}, 0) * ({m3} / ({y} + {b3})) / ({y} - {r}) + "
+        f"Max({y} - {a}, 0) * Max({r} - {y}, 0) * ({m2} * {y} + {b2}) / "
+        f"(({y} - {a}) * ({r} - {y}))"
     )
-    return problem.add_scalarization(scalar), symbol
+    return func
 
 
-def add_group_scenario_sf_diff(
+def add_desirability_funcs(
     problem: Problem,
-    symbol: str,
-    reference_points: list[dict[str, float]],
-    weights: list[dict[str, float]],
-    epsilon: float = 1e-6,
-) -> tuple[Problem, str]:
-    r"""Add the differentiable scenario-based scalarization.
-
-    Adds the following scalarization function:
-    \begin{align}
-      \min_{x,\alpha}\quad
-        & \alpha \;+\; \varepsilon \sum_{i,p} w_{ip}\bigl(f_{ip}(x) - \bar z_{ip}\bigr) \\
-      \text{s.t.}\quad
-        & w_{ip}\bigl(f_{ip}(x) - \bar z_{ip}\bigr)\;-\;\alpha \;\le\;0
-          \quad\forall\,i,p,\\
-        & x \in \mathcal{X}\,,
-    \end{align}
+    aspiration_levels: dict[str, float],
+    reservation_levels: dict[str, float],
+    desirability_levels: dict[str, tuple[float, float]] | None = None,
+    desirability_func: Literal["Harrington", "MaoMao"] = "Harrington",
+) -> tuple[Problem, list[str]]:
+    """Adds desirability functions to the problem based on the given aspiration and reservation levels.
+
+    Note that the desirability functions are added as scalarization functions to the problem. They are also multiplied
+    by -1 to ensure that "desirability" values can be minimized, as is assumed by the optimizers.
 
     Args:
-        problem (Problem): the problem the scalarization is added to.
-        symbol (str): the symbol given to the added scalarization.
-        reference_points (list[dict[str, float]]): a list of reference points as objective dicts.
-            function symbols and values to reference point components, i.e., aspiration levels.
-        weights (list[dict[str, float]]): the list of weights to be used in the scalarization function.
-            Must be positive.
-        epsilon: small augmentation multiplier ε
+        problem (Problem): The problem to which the desirability functions should be added.
+        aspiration_levels (dict[str, float]): A dictionary with keys corresponding to objective function symbols
+            and values to aspiration levels.
+        reservation_levels (dict[str, float]): A dictionary with keys corresponding to objective function symbols
+            and values to reservation levels.
+        desirability_levels (dict[str, tuple[float, float]] | None, optional): A dictionary with keys corresponding to
+            objective function symbols and values to desirability levels, where each value is a tuple of (d1, d2). If
+            not given, the default values for d1 and d2 are used, which are 0.9 and 0.1 respectively. Defaults to None.
+        desirability_func (str, optional): The type of desirability function to use. Currently, only "Harrington" or
+        "MaoMao" is supported. Defaults to "Harrington".
 
     Returns:
-        tuple[Problem, str]: A tuple containing a copy of the problem with the scalarization function added,
-            and the symbol of the added scalarization function.
+        Problem: A copy of the problem with the added desirability functions as scalarization functions.
+        list[str]: A list of symbols of the added desirability functions.
     """
-    if len(reference_points) != len(weights):
-        raise ScalarizationError("reference_points and weights must have same length")
-
-    for idx, (ref_point, weight) in enumerate(zip(reference_points, weights, strict=True)):
-        if not objective_dict_has_all_symbols(problem, ref_point):
-            raise ScalarizationError(f"reference_points[{idx}] missing some objectives")
-        if not objective_dict_has_all_symbols(problem, weight):
-            raise ScalarizationError(f"weights[{idx}] missing some objectives")
-
-    alpha = Variable(
-        name="alpha",
-        symbol="_alpha",
-        variable_type=VariableTypeEnum.real,
-        lowerbound=-float("Inf"),
-        upperbound=float("Inf"),
-        initial_value=0.0,
-    )
+    if desirability_func == "Harrington":
+        create_func = __create_HDF
+    elif desirability_func == "MaoMao":
+        create_func = __create_MDF
+    else:
+        raise ScalarizationError(f"Desirability function {desirability_func} is not supported.")
 
-    sum_list = []
-    constraints = []
+    if desirability_levels is None:
+        desirability_levels = {obj.symbol: (0.9, 0.1) for obj in problem.objectives}
 
-    for idx, (ref_point, weight) in enumerate(zip(reference_points, weights, strict=True)):
-        corrected_rp = get_corrected_reference_point(problem, ref_point)
-        for obj in problem.objectives:
-            expr = f"{weight[obj.symbol]}*({obj.symbol}_min - {corrected_rp[obj.symbol]})"
-            sum_list.append(expr)
-
-            constraints.append(
-                Constraint(
-                    name=f"ssf_con_{obj.symbol}",
-                    symbol=f"{obj.symbol}_con_{idx}",
-                    func=f"{expr} - {alpha.symbol}",
-                    cons_type=ConstraintTypeEnum.LTE,
-                    is_linear=obj.is_linear,
-                    is_convex=obj.is_convex,
-                    is_twice_differentiable=obj.is_twice_differentiable,
-                )
+    # check that all objectives have aspiration and reservation levels defined
+    for obj in problem.objectives:
+        if obj.symbol not in aspiration_levels or obj.symbol not in reservation_levels:
+            raise ScalarizationError(
+                f"Objective {obj.symbol} does not have both aspiration and reservation levels defined."
+            )
+    maximize: dict[str, int] = {obj.symbol: -1 if obj.maximize else 1 for obj in problem.objectives}
+    symbols = []
+    problem_: Problem = problem.model_copy(deep=True)
+    for obj in problem.objectives:
+        d1, d2 = desirability_levels[obj.symbol]
+        func = (
+            "- ("
+            + create_func(
+                obj.symbol + "_min",
+                aspiration_levels[obj.symbol] * maximize[obj.symbol],
+                reservation_levels[obj.symbol] * maximize[obj.symbol],
+                d1,
+                d2,
             )
+            + ")"
+        )
+        symbols.append(f"{obj.symbol}_d")
+        scalarization = ScalarizationFunction(
+            name=f"Desirability function for {obj.symbol}",
+            symbol=f"{obj.symbol}_d",
+            func=func,
+            is_linear=False,
+            is_convex=False,
+            is_twice_differentiable=obj.is_twice_differentiable,
+        )
+        problem_ = problem_.add_scalarization(scalarization)
 
-    sum_part = " + ".join(sum_list)
+    return problem_, symbols
 
-    func = f"_alpha + {epsilon}*({sum_part})"
-    scalar = ScalarizationFunction(
-        name="Scenario-based differentiable ASF",
-        symbol=symbol,
-        func=func,
-        is_linear=problem.is_linear,
-        is_convex=problem.is_convex,
-        is_twice_differentiable=problem.is_twice_differentiable,
-    )
 
-    problem_ = problem.add_variables([alpha])
-    problem_ = problem_.add_constraints(constraints)
-    problem_ = problem_.add_scalarization(scalar)
+def add_iopis_funcs(
+    problem: Problem,
+    reference_point: dict[str, float],
+    ideal: dict[str, float] | None = None,
+    nadir: dict[str, float] | None = None,
+    rho: float = 1e-6,
+    delta: float = 1e-6,
+) -> tuple[Problem, list[str]]:
+    symbols = ["iopis_guess", "iopis_stom"]
+    _problem, _ = add_guess_sf_nondiff(
+        problem=problem,
+        symbol=symbols[0],
+        reference_point=reference_point,
+        ideal=ideal,
+        nadir=nadir,
+        rho=rho,
+    )
 
-    return problem_, symbol
+    _problem, _ = add_stom_sf_nondiff(
+        problem=_problem,
+        symbol=symbols[1],
+        reference_point=reference_point,
+        ideal=ideal,
+        delta=delta,
+    )
+    return _problem, symbols