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

desdeo/problem/testproblems/{river_pollution_problem.py → river_pollution_problems.py}

@@ -1,3 +1,5 @@
+"""Variants of the river pollution problem are defined here."""
+
 from pathlib import Path
 
 import polars as pl
@@ -12,6 +14,7 @@ from desdeo.problem.schema import (
     VariableTypeEnum,
 )
 
+
 def river_pollution_problem(*, five_objective_variant: bool = True) -> Problem:
     r"""Create a pydantic dataclass representation of the river pollution problem with either five or four variables.
 
@@ -164,34 +167,34 @@ def river_pollution_problem_discrete(*, five_objective_variant: bool = True) ->
             Heidelberg, 1997.
     """
     filename = "datasets/river_poll_4_objs.csv"
-    trueVarNames = {"x_1": "BOD", "x_2": "DO"}
-    trueObjNames = {"f1": "DO city", "f2": "DO municipality", "f3": "ROI fishery", "f4": "ROI city"}
+    true_var_names = {"x_1": "BOD", "x_2": "DO"}
+    true_obj_names = {"f1": "DO city", "f2": "DO municipality", "f3": "ROI fishery", "f4": "ROI city"}
     if five_objective_variant:
         filename = "datasets/river_poll_5_objs.csv"
-        trueObjNames["f5"] = "BOD deviation"
+        true_obj_names["f5"] = "BOD deviation"
 
     path = Path(__file__).parent.parent.parent.parent / filename
     data = pl.read_csv(path, has_header=True)
 
     variables = [
         Variable(
-            name=trueVarNames[varName],
+            name=true_var_names[varName],
             symbol=varName,
             variable_type=VariableTypeEnum.real,
             lowerbound=0.3,
             upperbound=1.0,
             initial_value=0.65,
         )
-        for varName in trueVarNames
+        for varName in true_var_names
     ]
     maximize = {"f1": True, "f2": True, "f3": True, "f4": True, "f5": False}
-    ideal = {objName: (data[objName].max() if maximize[objName] else data[objName].min()) for objName in trueObjNames}
-    nadir = {objName: (data[objName].min() if maximize[objName] else data[objName].max()) for objName in trueObjNames}
+    ideal = {objName: (data[objName].max() if maximize[objName] else data[objName].min()) for objName in true_obj_names}
+    nadir = {objName: (data[objName].min() if maximize[objName] else data[objName].max()) for objName in true_obj_names}
     units = {"f1": "mg/L", "f2": "mg/L", "f3": "%", "f4": "%", "f5": "mg/L"}
 
     objectives = [
         Objective(
-            name=trueObjNames[objName],
+            name=true_obj_names[objName],
             symbol=objName,
             func=None,
             unit=units[objName],
@@ -200,12 +203,12 @@ def river_pollution_problem_discrete(*, five_objective_variant: bool = True) ->
             ideal=ideal[objName],
             nadir=nadir[objName],
         )
-        for objName in trueObjNames
+        for objName in true_obj_names
     ]
 
     discrete_def = DiscreteRepresentation(
-        variable_values=data[list(trueVarNames.keys())].to_dict(),
-        objective_values=data[list(trueObjNames.keys())].to_dict(),
+        variable_values=data[list(true_var_names.keys())].to_dict(),
+        objective_values=data[list(true_obj_names.keys())].to_dict(),
     )
 
     return Problem(
@@ -254,8 +257,10 @@ def river_pollution_scenario() -> Problem:
     $$
     \\begin{equation}
     \\begin{array}{rll}
-    \\text{maximize}   & f_1(\\mathbf{x}) = & \\alpha + \\left(\\log\\left(\\left(\\frac{\\beta}{2} - 1.14\\right)^2\\right) + \\beta^3\\right) x_1 \\\\
-    \\text{maximize}   & f_2(\\mathbf{x}) = & \\gamma + \\delta x_1 + \\xi x_2 + \\frac{0.01}{\\eta - x_1^2} + \\frac{0.30}{\\eta - x_2^2} \\\\
+    \\text{maximize}   & f_1(\\mathbf{x}) = & \\alpha + \\left(\\log\\left(\\left(\\frac{\\beta}{2}
+        - 1.14\\right)^2\\right) + \\beta^3\\right) x_1 \\\\
+    \\text{maximize}   & f_2(\\mathbf{x}) = & \\gamma + \\delta x_1 + \\xi x_2 + \\frac{0.01}{\\eta - x_1^2}
+        + \\frac{0.30}{\\eta - x_2^2} \\\\
     \\text{maximize}   & f_3(\\mathbf{x}) = & r - \\frac{0.71}{1.09 - x_1^2} \\\\
     \\text{minimize}   & f_4(\\mathbf{x}) = & -0.96 + \\frac{0.96}{1.09 - x_2^2} \\\\
     \\text{subject to} & & 0.3 \\leq x_1, x_2 \\leq 1.0.
@@ -278,7 +283,7 @@ def river_pollution_scenario() -> Problem:
             Analysis: Proceedings of the XIth International Conference on MCDM, 1-6
             August 1994, Coimbra, Portugal. Berlin, Heidelberg: Springer Berlin
             Heidelberg, 1997.
-    """
+    """  # noqa: RUF002
     num_scenarios = 6
     scenario_key_stub = "scenario"
 
@@ -351,22 +356,23 @@ def river_pollution_scenario() -> Problem:
     scenario_keys = []
 
     for i in range(num_scenarios):
-        scenario_key = f"{scenario_key_stub}_{i+1}"
+        scenario_key = f"{scenario_key_stub}_{i + 1}"
         scenario_keys.append(scenario_key)
 
-        gamma_expr = f"Ln(alpha[{i+1}]/2 - 1) + alpha[{i+1}]/2 + 1.5"
+        gamma_expr = f"Ln(alpha[{i + 1}]/2 - 1) + alpha[{i + 1}]/2 + 1.5"
 
-        f1_expr = f"alpha[{i+1}] + (Ln((beta[{i+1}]/2 - 1.14)**2) + beta[{i+1}]**3)*x_1"
+        f1_expr = f"alpha[{i + 1}] + (Ln((beta[{i + 1}]/2 - 1.14)**2) + beta[{i + 1}]**3)*x_1"
         f2_expr = (
-            f"{gamma_expr} + delta[{i+1}]*x_1 + xi[{i+1}]*x_2 + 0.01/(eta[{i+1}] - x_1**2) + 0.3/(eta[{i+1}] - x_2**2)"
+            f"{gamma_expr} + delta[{i + 1}]*x_1 + xi[{i + 1}]*x_2 + 0.01/(eta[{i + 1}] - x_1**2) "
+            f"+ 0.3/(eta[{i + 1}] - x_2**2)"
         )
-        f3_expr = f"r[{i+1}]  - 0.71/(1.09 - x_1**2)"
+        f3_expr = f"r[{i + 1}]  - 0.71/(1.09 - x_1**2)"
 
         # f1
         objectives.append(
             Objective(
                 name="DO level city",
-                symbol=f"f1_{i+1}",
+                symbol=f"f1_{i + 1}",
                 scenario_keys=[scenario_key],
                 func=f1_expr,
                 objective_type=ObjectiveTypeEnum.analytical,
@@ -381,7 +387,7 @@ def river_pollution_scenario() -> Problem:
         objectives.append(
             Objective(
                 name="DO level fishery",
-                symbol=f"f2_{i+1}",
+                symbol=f"f2_{i + 1}",
                 scenario_keys=[scenario_key],
                 func=f2_expr,
                 objective_type=ObjectiveTypeEnum.analytical,
@@ -396,7 +402,7 @@ def river_pollution_scenario() -> Problem:
         objectives.append(
             Objective(
                 name="Return of investment",
-                symbol=f"f3_{i+1}",
+                symbol=f"f3_{i + 1}",
                 scenario_keys=[scenario_key],
                 func=f3_expr,
                 objective_type=ObjectiveTypeEnum.analytical,

desdeo/problem/testproblems/single_objective.py

@@ -0,0 +1,289 @@
+"""Here a variety of single-objective optimization problems are defined."""
+
+import math
+
+from desdeo.problem import (
+    Constant,
+    Constraint,
+    ConstraintTypeEnum,
+    ExtraFunction,
+    Objective,
+    Problem,
+    Variable,
+    VariableTypeEnum,
+)
+
+
+def mystery_function() -> Problem:
+    r"""Add the constrained mystery function as defined in Sasena 2002.
+
+    Global solution's value (constrained): -1.174261 at x = [2.5044, 2.5778].
+
+    Returns:
+        Problem: the problem model.
+
+    References:
+        Michael Sasena. 2002. Flexibility and Eiciency Enhancements For
+            Constrained Global Design Optimization with Kriging Approximations. Ph.D.  Dissertation.
+    """
+    pi = Constant(name="Pi", symbol="PI", value=math.pi)
+    x_1 = Variable(
+        name="x_1", symbol="x_1", variable_type=VariableTypeEnum.real, lowerbound=0.0, upperbound=5.0, initial_value=0.1
+    )
+    x_2 = Variable(
+        name="x_2", symbol="x_2", variable_type=VariableTypeEnum.real, lowerbound=0.0, upperbound=5.0, initial_value=0.1
+    )
+
+    f_1_def = "2 + 0.01*(x_2 - x_1**2)**2 + (1 - x_1)**2 + 2*(2 - x_2)**2 + 7*Sin(0.5*x_1)*Sin(0.7*x_1*x_2)"
+    f_1 = Objective(
+        name="f_1",
+        symbol="f_1",
+        func=f_1_def,
+        maximize=False,
+        is_linear=False,
+        is_convex=False,
+        is_twice_differentiable=True,
+    )
+
+    c_1_def = "-Sin(x_1 - x_2 - PI/8.0)"
+    c_1 = Constraint(
+        name="c_1",
+        symbol="c_1",
+        cons_type=ConstraintTypeEnum.LTE,
+        func=c_1_def,
+        is_linear=False,
+        is_convex=False,
+        is_twice_differentiable=True,
+    )
+
+    return Problem(
+        name="Mystery function",
+        description="The single-objective mystery function.",
+        constants=[pi],
+        variables=[x_1, x_2],
+        objectives=[f_1],
+        constraints=[c_1],
+    )
+
+
+def new_branin_function() -> Problem:
+    """Implements the new Branin function.
+
+    Global optimal -268.78792 at x = [3.2730, 0.0489].
+    """
+    pi = Constant(name="Pi", symbol="PI", value=math.pi)
+    x_1 = Variable(
+        name="x_1",
+        symbol="x_1",
+        variable_type=VariableTypeEnum.real,
+        lowerbound=-5.0,
+        upperbound=10.0,
+        initial_value=0.1,
+    )
+    x_2 = Variable(
+        name="x_2",
+        symbol="x_2",
+        variable_type=VariableTypeEnum.real,
+        lowerbound=0.0,
+        upperbound=15.0,
+        initial_value=0.1,
+    )
+
+    f_1_def = "-(x_1 - 10)**2 - (x_2 - 15)**2"
+    f_1 = Objective(
+        name="f_1",
+        symbol="f_1",
+        func=f_1_def,
+        maximize=False,
+        is_linear=False,
+        is_convex=False,
+        is_twice_differentiable=True,
+    )
+
+    c_1_def = "(x_2 - (5.1 / (4*PI**2)) * x_1**2 + (5 / PI)*x_1 - 6)**2 + 10*(1 - 1/(8*PI))*Cos(x_1) + 5"
+    c_1 = Constraint(
+        name="c_1",
+        symbol="c_1",
+        cons_type=ConstraintTypeEnum.LTE,
+        func=c_1_def,
+        is_linear=False,
+        is_convex=False,
+        is_twice_differentiable=True,
+    )
+
+    return Problem(
+        name="New Branin function",
+        description="The single-objective mystery function.",
+        constants=[pi],
+        variables=[x_1, x_2],
+        objectives=[f_1],
+        constraints=[c_1],
+    )
+
+
+def mishras_bird_constrained() -> Problem:
+    """Implements the constrained variant of Mishra's bird function.
+
+    Global optima: -106.7645367 at [-3.1302468, -1.5821422]
+    """
+    x_1 = Variable(
+        name="x_1",
+        symbol="x_1",
+        variable_type=VariableTypeEnum.real,
+        lowerbound=-10.0,
+        upperbound=0.0,
+        initial_value=-0.1,
+    )
+    x_2 = Variable(
+        name="x_2",
+        symbol="x_2",
+        variable_type=VariableTypeEnum.real,
+        lowerbound=-6.5,
+        upperbound=0.0,
+        initial_value=-0.1,
+    )
+
+    f_1_def = "Sin(x_2)*Exp((1 - Cos(x_1))**2) + Cos(x_1)*Exp((1 - Sin(x_2))**2) + (x_1 - x_2)**2"
+    f_1 = Objective(
+        name="f_1",
+        symbol="f_1",
+        func=f_1_def,
+        maximize=False,
+        is_linear=False,
+        is_convex=False,
+        is_twice_differentiable=True,
+    )
+
+    c_1_def = "(x_1 + 5)**2 + (x_2 + 5)**2 - 25"
+    c_1 = Constraint(
+        name="c_1",
+        symbol="c_1",
+        cons_type=ConstraintTypeEnum.LTE,
+        func=c_1_def,
+        is_linear=False,
+        is_convex=False,
+        is_twice_differentiable=True,
+    )
+
+    return Problem(
+        name="Mishra's bird function",
+        description="The constrained variant of Mishra's bird function",
+        variables=[x_1, x_2],
+        objectives=[f_1],
+        constraints=[c_1],
+    )
+
+
+def rosenbrock_disk() -> Problem:
+    """Defines the Rosenbrock test functions constrained to a disk.
+
+    Global optima is 0 at [1.0, 1.0].
+    """
+    x = Variable(
+        name="x",
+        symbol="x",
+        variable_type=VariableTypeEnum.real,
+        lowerbound=-1.5,
+        upperbound=1.5,
+        initial_value=0.1,
+    )
+    y = Variable(
+        name="y",
+        symbol="y",
+        variable_type=VariableTypeEnum.real,
+        lowerbound=-1.5,
+        upperbound=1.5,
+        initial_value=0.1,
+    )
+
+    f_1_def = "(1 - x)**2 + 100*(y - x**2)**2"
+    f_1 = Objective(
+        name="f_1",
+        symbol="f_1",
+        func=f_1_def,
+        maximize=False,
+        is_linear=False,
+        is_convex=False,
+        is_twice_differentiable=True,
+    )
+
+    c_1_def = "x**2 + y**2 - 2.0"
+    c_1 = Constraint(
+        name="c_1",
+        symbol="c_1",
+        cons_type=ConstraintTypeEnum.LTE,
+        func=c_1_def,
+        is_linear=False,
+        is_convex=False,
+        is_twice_differentiable=True,
+    )
+
+    return Problem(
+        name="Rosenbrock test function",
+        description="The Rosenbrock test function constrained to a disk.",
+        variables=[x, y],
+        objectives=[f_1],
+        constraints=[c_1],
+    )
+
+
+def townsend_modified() -> Problem:
+    """Implements the modified Townsend function.
+
+    Global optima is -2.0239884 at [2.0052938, 1.1944509].
+    """
+    x = Variable(
+        name="x",
+        symbol="x",
+        variable_type=VariableTypeEnum.real,
+        lowerbound=-2.25,
+        upperbound=2.25,
+        initial_value=0.1,
+    )
+    y = Variable(
+        name="y",
+        symbol="y",
+        variable_type=VariableTypeEnum.real,
+        lowerbound=-2.5,
+        upperbound=1.75,
+        initial_value=0.1,
+    )
+
+    f_1_def = "-1.0 * (Cos((x - 0.1)*y))**2 - x*Sin(3.0*x + y)"
+    f_1 = Objective(
+        name="f_1",
+        symbol="f_1",
+        func=f_1_def,
+        maximize=False,
+        is_linear=False,
+        is_convex=False,
+        is_twice_differentiable=True,
+    )
+
+    # define the atan2 functions as the double of the arctangent of the half tangent
+    # Obs! Risk of dividing by zero!
+    t_symbol = "t"
+    t_def = "2.0*Arctan(x / (Sqrt(y**2 + x**2) + y))"
+    t = ExtraFunction(
+        name="Atan2", symbol=t_symbol, func=t_def, is_convex=False, is_linear=False, is_twice_differentiable=True
+    )
+
+    c_1_def = "x**2 + y**2 - (2.0*Cos(t) - 0.5*Cos(2.0*t) - 0.25*Cos(3.0*t) - 0.125*Cos(4.0*t))**2 - (2.0*Sin(t))**2"
+    c_1 = Constraint(
+        name="c_1",
+        symbol="c_1",
+        cons_type=ConstraintTypeEnum.LTE,
+        func=c_1_def,
+        is_linear=False,
+        is_convex=False,
+        is_twice_differentiable=True,
+    )
+
+    return Problem(
+        name="Townsend function",
+        description="The modified Townsend function.",
+        variables=[x, y],
+        objectives=[f_1],
+        constraints=[c_1],
+        extra_funcs=[t],
+    )

desdeo/problem/testproblems/zdt_problem.py

@@ -1,3 +1,5 @@
+from math import pi
+
 from desdeo.problem.schema import (
     ExtraFunction,
     Objective,
@@ -5,6 +7,7 @@ from desdeo.problem.schema import (
     Variable,
 )
 
+
 def zdt1(number_of_variables: int) -> Problem:
     r"""Defines the ZDT1 test problem.
 
@@ -214,7 +217,7 @@ def zdt3(
 
     # function h(f, g)
     h_symbol = "h"
-    h_expr = f"1 - Sqrt(({f1_expr}) / ({g_expr})) - (({f1_expr}) / ({g_expr})) * Sin (10 * {np.pi} * {f1_expr}) "
+    h_expr = f"1 - Sqrt(({f1_expr}) / ({g_expr})) - (({f1_expr}) / ({g_expr})) * Sin (10 * {pi} * {f1_expr}) "
 
     # function f_2
     f2_symbol = "f_2"

desdeo/tools/__init__.py

@@ -3,8 +3,8 @@
 __all__ = [
     "BaseSolver",
     "BonminOptions",
-    "IpoptOptions",
     "GurobipySolver",
+    "IpoptOptions",
     "NevergradGenericOptions",
     "NevergradGenericSolver",
     "PersistentGurobipySolver",
@@ -13,26 +13,34 @@ __all__ = [
     "PyomoCBCSolver",
     "PyomoGurobiSolver",
     "PyomoIpoptSolver",
+    "ScalarizationError",
     "ScipyDeSolver",
     "ScipyMinimizeSolver",
     "SolverOptions",
     "SolverResults",
-    "ScalarizationError",
     "add_asf_diff",
-    "add_asf_generic_nondiff",
     "add_asf_generic_diff",
+    "add_asf_generic_nondiff",
     "add_asf_nondiff",
     "add_epsilon_constraints",
-    "add_guess_sf_diff",
-    "add_guess_sf_nondiff",
     "add_group_asf",
+    "add_group_asf_agg",
+    "add_group_asf_agg_diff",
     "add_group_asf_diff",
-    "add_group_guess_sf",
-    "add_group_guess_sf_diff",
-    "add_group_nimbus_sf",
-    "add_group_nimbus_sf_diff",
-    "add_group_stom_sf",
-    "add_group_stom_sf_diff",
+    "add_group_guess",
+    "add_group_guess_agg",
+    "add_group_guess_agg_diff",
+    "add_group_guess_diff",
+    "add_group_nimbus",
+    "add_group_nimbus_compromise",
+    "add_group_nimbus_compromise_diff",
+    "add_group_nimbus_diff",
+    "add_group_stom",
+    "add_group_stom_agg",
+    "add_group_stom_agg_diff",
+    "add_group_stom_diff",
+    "add_guess_sf_diff",
+    "add_guess_sf_nondiff",
     "add_nimbus_sf_diff",
     "add_nimbus_sf_nondiff",
     "add_objective_as_scalarization",
@@ -42,13 +50,31 @@ __all__ = [
     "available_nevergrad_optimizers",
     "available_solvers",
     "find_compatible_solvers",
+    "flip_maximized_objective_values",
     "get_corrected_ideal_and_nadir",
-    "get_corrected_reference_point",
     "guess_best_solver",
     "payoff_table_method",
 ]
 
 from desdeo.tools.generics import BaseSolver, SolverOptions, SolverResults
+from desdeo.tools.group_scalarization import (
+    add_group_asf,
+    add_group_asf_agg,
+    add_group_asf_agg_diff,
+    add_group_asf_diff,
+    add_group_guess,
+    add_group_guess_agg,
+    add_group_guess_agg_diff,
+    add_group_guess_diff,
+    add_group_nimbus,
+    add_group_nimbus_compromise,
+    add_group_nimbus_compromise_diff,
+    add_group_nimbus_diff,
+    add_group_stom,
+    add_group_stom_agg,
+    add_group_stom_agg_diff,
+    add_group_stom_diff,
+)
 from desdeo.tools.gurobipy_solver_interfaces import (
     GurobipySolver,
     PersistentGurobipySolver,
@@ -74,14 +100,6 @@ from desdeo.tools.scalarization import (
     add_asf_generic_nondiff,
     add_asf_nondiff,
     add_epsilon_constraints,
-    add_group_asf,
-    add_group_asf_diff,
-    add_group_guess_sf,
-    add_group_guess_sf_diff,
-    add_group_nimbus_sf,
-    add_group_nimbus_sf_diff,
-    add_group_stom_sf,
-    add_group_stom_sf_diff,
     add_guess_sf_diff,
     add_guess_sf_nondiff,
     add_nimbus_sf_diff,
@@ -95,8 +113,8 @@ from desdeo.tools.scipy_solver_interfaces import ScipyDeSolver, ScipyMinimizeSol
 from desdeo.tools.utils import (
     available_solvers,
     find_compatible_solvers,
+    flip_maximized_objective_values,
     get_corrected_ideal_and_nadir,
-    get_corrected_reference_point,
     guess_best_solver,
     payoff_table_method,
 )

desdeo/tools/desc_gen.py

@@ -0,0 +1,22 @@
+"""An utility function to generate descriptions related to UTOPIA matters"""
+
+def generate_descriptions(mapjson: dict, sid: str, stand: str, holding: str, extension: str) -> dict:
+    descriptions = {}
+    if holding:
+        for feat in mapjson["features"]:
+            if False:  # noqa: SIM108
+                ext = f".{feat["properties"][extension]}"
+            else:
+                ext = ""
+            descriptions[feat["properties"][sid]] = (
+                f"Ala {feat["properties"][holding].split("-")[-1]} kuvio {feat["properties"][stand]}{ext}: "
+            )
+    else:
+        for feat in mapjson["features"]:
+            if False:  # noqa: SIM108
+                ext = f".{feat["properties"][extension]}"
+            else:
+                ext = ""
+            descriptions[feat["properties"][sid]
+                         ] = f"Kuvio {feat["properties"][stand]}{ext}: "
+    return descriptions

desdeo/tools/generics.py

@@ -3,7 +3,8 @@
 from abc import ABC, abstractmethod
 from typing import Any, TypeVar
 
-from pydantic import BaseModel, Field
+import polars as pl
+from pydantic import BaseModel, ConfigDict, Field, field_serializer
 
 from desdeo.problem import (
     Constraint,
@@ -18,6 +19,25 @@ class SolverError(Exception):
     """Raised when an error with a solver is encountered."""
 
 
+class EMOResult(BaseModel):
+    """Defines a schema for a dataclass to store the results of an EMO method."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True, use_attribute_docstrings=True)
+
+    optimal_variables: pl.DataFrame = Field()
+    """The decision vectors of the final population."""
+    optimal_outputs: pl.DataFrame = Field()
+    """The objective vectors, constraint vectors, extra_funcs, and targets of the final population."""
+
+    @field_serializer("optimal_variables")
+    def _serialize_optimal_variables(self, value: pl.DataFrame) -> dict[str, list[int | float]]:
+        return value.to_dict(as_series=False)
+
+    @field_serializer("optimal_outputs")
+    def _serialize_optimal_outputs(self, value: pl.DataFrame) -> dict[str, list[int | float]]:
+        return value.to_dict(as_series=False)
+
+
 class SolverResults(BaseModel):
     """Defines a schema for a dataclass to store the results of a solver."""
 
@@ -25,7 +45,7 @@ class SolverResults(BaseModel):
     optimal_objectives: dict[str, float | list[float]] = Field(
         description="The objective function values corresponding to the optimal decision variables found."
     )
-    constraint_values: dict[str, float | list[float]] | None = Field(
+    constraint_values: dict[str, float | int | list[float] | list] | None | Any = Field(
         description=(
             "The constraint values of the problem. A negative value means the constraint is respected, "
             "a positive one means it has been breached."