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

desdeo/problem/testproblems/cake_problem.py

@@ -0,0 +1,185 @@
+"""Defines the 'best cake problem'."""
+
+from desdeo.problem.schema import (
+    Constant,
+    Objective,
+    ObjectiveTypeEnum,
+    Problem,
+    Variable,
+    VariableTypeEnum,
+)
+
+PI = 3.14159265358979323846
+
+
+## Helper func
+def U(z: float):
+    return 4.0 * z * (1.0 - z)
+
+
+## Helper funcs to return string representations
+
+
+def bowl_str(z: str, a: str, invD: str) -> str:
+    tmp: str = f"({z} - {a})*{invD}"
+    return f"({tmp}*{tmp})"
+    # return f"{clamp01_str(f"{tmp}*{tmp}")}"
+
+
+def U_str(z: str) -> str:
+    tmp: str = f"(4*{z}*(1.0 - {z}))"
+    return f"({tmp}*{tmp})"
+
+
+def ripple_str(t: str) -> str:
+    tmp: str = f"Sin({PI} * {t})"
+    return f"({tmp}*{tmp})"
+
+
+# Objective function string representations
+def f0_str() -> str:
+    yliq: str = "(0.5*x5 + 0.3*x4 + 0.2*x3)"
+    v: str = (
+        f"(0.4 * {bowl_str('x1', 'T1', 'INV_D1')}) + "
+        f"(0.4 * {bowl_str(yliq, 'Y_LIQ_STAR', 'INV_D_YLIQ')}) + "
+        f" (0.2 * {ripple_str('((x1 + x6) - (T1 + T6))')})"
+    )
+    return f"14*({v})"
+
+
+def f1_str() -> str:
+    sbar: str = "((x2 + 0.5*x3)/1.5)"
+    w25: str = f"({U_str('x2')}*{U_str('x5')})"
+    d25: str = f"(({w25} - W25_STAR)*INV_DW25)"
+    v: str = f"(0.4*{bowl_str('x2', 'T2', 'INV_D2')}) + (0.3*{ripple_str(f'{sbar} - SBAR_STAR')}) +(0.3*{d25}*{d25})"
+    return f"14*({v})"
+
+
+def f2_str() -> str:
+    v: str = (
+        f"(0.35*{bowl_str('x6', 'T6', 'INV_D6')}) + "
+        f"(0.25*{bowl_str('x4', 'T4', 'INV_D4')}) + "
+        f"(0.4*{ripple_str('((x6 - 0.5*x4) - (T6 - 0.5*T4))')})"
+    )
+    return f"14*({v})"
+
+
+def f3_str() -> str:
+    w35: str = f"({U_str('x3')}*{U_str('x5')})"
+    d35: str = f"(({w35} - W35_STAR) * INV_DW35)"
+    v: str = f"(0.3*{bowl_str('x3', 'T3', 'INV_D3')}) + (0.3*{bowl_str('x5', 'T5', 'INV_D5')}) + (0.4*({d35}*{d35}))"
+    return f"14*({v})"
+
+
+def f4_str() -> str:
+    v: str = (
+        f"(0.25*{bowl_str('x2', 'T2', 'INV_D2')}) + "
+        f"(0.25*{bowl_str('x3', 'T3', 'INV_D3')}) + "
+        f"(0.20*{ripple_str('(x4 - T4)')}) + "
+        f"(0.30*{ripple_str('((x2 - x5) - (T2 - T5))')})"
+    )
+    return f"14*({v})"
+
+
+## The cake problem
+def best_cake_problem() -> Problem:
+    """Defines the best cake problem."""
+    variable_inits = [
+        ("Flour", 0.70),
+        ("Sugar", 0.10),
+        ("Butter", 0.40),
+        ("Eggs", 0.50),
+        ("Milk", 0.20),
+        ("Baking powder", 0.80),
+    ]
+    variables = [
+        Variable(
+            name=var[0],
+            symbol=f"x{i + 1}",
+            variable_type=VariableTypeEnum.real,
+            lowerbound=0.0,
+            upperbound=1.0,
+            initial_value=var[1],
+        )
+        for i, var in enumerate(variable_inits)
+    ]
+
+    constants_init = [
+        ("T1", 0.60),
+        ("T2", 0.35),
+        ("T3", 0.25),
+        ("T4", 0.30),
+        ("T5", 0.35),
+        ("T6", 0.40),
+        ("INV_D1", 1.0 / 0.60),
+        ("INV_D2", 1.0 / 0.65),
+        ("INV_D3", 1.0 / 0.75),
+        ("INV_D4", 1.0 / 0.70),
+        ("INV_D5", 1.0 / 0.65),
+        ("INV_D6", 1.0 / 0.60),
+        ("Y_LIQ_STAR", 0.5 * 0.35 + 0.3 * 0.30 + 0.2 * 0.25),
+        ("INV_D_YLIQ", 1.0 / 0.685),
+        ("SBAR_STAR", (0.35 + 0.5 * 0.25) / 1.5),
+        ("W25_STAR", U(0.35) * U(0.35)),
+        ("INV_DW25", 1.0 / 0.8281),
+        ("W35_STAR", U(0.25) * U(0.35)),
+        ("INV_DW35", 1.0 / 0.6825),
+    ]
+
+    constants = [Constant(name=const[0], symbol=const[0], value=const[1]) for const in constants_init]
+
+    objectives = [
+        Objective(
+            name="Dry/crumb error",
+            symbol="dry_crumb",
+            func=f0_str(),
+            ideal=0.0,
+            nadir=14.0,
+            objective_type=ObjectiveTypeEnum.analytical,
+            is_twice_differentiable=True,  # right?
+        ),
+        Objective(
+            name="Sweetness/texture off-target",
+            symbol="sweet_texture",
+            func=f1_str(),
+            ideal=0.0,
+            nadir=14.0,
+            objective_type=ObjectiveTypeEnum.analytical,
+            is_twice_differentiable=True,
+        ),
+        Objective(
+            name="Rise/collapse risk",
+            symbol="rise_collapse",
+            func=f2_str(),
+            ideal=0.0,
+            nadir=14.0,
+            objective_type=ObjectiveTypeEnum.analytical,
+            is_twice_differentiable=True,
+        ),
+        Objective(
+            name="Moistness/grease imbalance",
+            symbol="moistness_grease",
+            func=f3_str(),
+            ideal=0.0,
+            nadir=14.0,
+            objective_type=ObjectiveTypeEnum.analytical,
+            is_twice_differentiable=True,
+        ),
+        Objective(
+            name="Browning/burn risk",
+            symbol="browning_burn",
+            func=f4_str(),
+            ideal=0.0,
+            nadir=14.0,
+            objective_type=ObjectiveTypeEnum.analytical,
+            is_twice_differentiable=True,
+        ),
+    ]
+
+    return Problem(
+        name="Cake problem",
+        description="Try to find the most delicious cake!",
+        constants=constants,
+        variables=variables,
+        objectives=objectives,
+    )

desdeo/problem/testproblems/dmitry_forest_problem_discrete.py

@@ -0,0 +1,71 @@
+"""A forest problem with discrete representation."""
+from pathlib import Path
+
+import polars as pl
+
+from desdeo.problem.schema import (
+    DiscreteRepresentation,
+    Objective,
+    ObjectiveTypeEnum,
+    Problem,
+    Variable,
+    VariableTypeEnum,
+)
+
+
+def dmitry_forest_problem_disc() -> Problem:
+    """Implements the dmitry forest problem using Pareto front representation.
+
+    Returns:
+        Problem: A problem instance representing the forest problem.
+    """
+    path = Path(__file__)
+    while not str(path).endswith("/DESDEO"):
+        path = path.parent
+
+    path = path / "tests/data/dmitry_discrete_repr/dmitry_forest_problem_non_dom_solns.csv"
+
+    obj_names = ["Rev", "HA", "Carb", "DW"]
+
+    var_name = "index"
+
+    data = pl.read_csv(
+        path, has_header=True, columns=["Rev", "HA", "Carb", "DW"], separator=",", #decimal_comma=True
+    )
+
+    variables = [
+        Variable(
+            name=var_name,
+            symbol=var_name,
+            variable_type=VariableTypeEnum.integer,
+            lowerbound=0,
+            upperbound=len(data) - 1,
+            initial_value=0,
+        )
+    ]
+
+    objectives = [
+        Objective(
+            name=obj_name,
+            symbol=obj_name,
+            objective_type=ObjectiveTypeEnum.data_based,
+            ideal=data[obj_name].max(),
+            nadir=data[obj_name].min(),
+            maximize=True,
+        )
+        for obj_name in obj_names
+    ]
+
+    discrete_def = DiscreteRepresentation(
+        variable_values={"index": list(range(len(data)))},
+        objective_values=data[[obj.symbol for obj in objectives]].to_dict(),
+    )
+
+    return Problem(
+        name="Dmitry Forest Problem (Discrete)",
+        description="Defines a forest problem with four objectives: revenue, habitat availability, carbon storage, and deadwood.",
+        variables=variables,
+        objectives=objectives,
+        discrete_representation=discrete_def,
+        is_twice_differentiable=False,
+    )

desdeo/problem/testproblems/forest_problem.py

@@ -16,7 +16,13 @@ from desdeo.problem.schema import (
     VariableTypeEnum,
 )
 
-def forest_problem(simulation_results: str, treatment_key: str, holding: int = 1, comparing: bool = False) -> Problem:
+
+def forest_problem(
+    simulation_results: str = "./tests/data/alternatives_290124.csv",
+    treatment_key: str = "./tests/data/alternatives_key_290124.csv",
+    holding: int = 1,
+    comparing: bool = False,
+) -> Problem:
     r"""Defines a test forest problem that has TensorConstants and TensorVariables.
 
     The problem has TensorConstants V, W and P as vectors taking values from a data file and
@@ -45,8 +51,8 @@ def forest_problem(simulation_results: str, treatment_key: str, holding: int = 1
         simulation_results (str): Location of the simulation results file.
         treatment_key (str): Location of the file with the treatment information.
         holding (int, optional): The number of the holding to be optimized. Defaults to 1.
-        comparing (bool, optional): Determines if solutions are to be compared to those from the rahti app.
-            Defaults to False.
+        comparing (bool, optional): This is only used for testing the method.
+            If comparing == True, the results are nonsense. Defaults to False.
 
     Returns:
         Problem: An instance of the test forest problem.
@@ -54,58 +60,60 @@ def forest_problem(simulation_results: str, treatment_key: str, holding: int = 1
     df = pl.read_csv(simulation_results, schema_overrides={"unit": pl.Float64})
     df_key = pl.read_csv(treatment_key, schema_overrides={"unit": pl.Float64})
 
-    selected_df_v = df.filter(pl.col("holding") == holding).select(["unit", "schedule", "npv_5_percent"])
-    unique_units = selected_df_v.unique(["unit"], maintain_order=True).get_column("unit")
-    selected_df_v.group_by(["unit", "schedule"])
-    rows_by_key = selected_df_v.rows_by_key(key=["unit", "schedule"])
-    v_array = np.zeros((selected_df_v["unit"].n_unique(), selected_df_v["schedule"].n_unique()))
-    for i in range(np.shape(v_array)[0]):
-        for j in range(np.shape(v_array)[1]):
-            if (unique_units[i], j) in rows_by_key:
-                v_array[i][j] = rows_by_key[(unique_units[i], j)][0]
-
-    # determine whether the results are to be compared to those from the rahti app (for testing purposes)
-    # if compared, the stock values are calculated by substacting the value after 2025 period from
-    # the value after the 2035 period (in other words, last value - first value)
-    if comparing:
-        selected_df_w = df.filter(pl.col("holding") == holding).select(["unit", "schedule", "stock_2025", "stock_2035"])
-        selected_df_w.group_by(["unit", "schedule"])
-        rows_by_key = selected_df_w.rows_by_key(key=["unit", "schedule"])
-        selected_df_key_w = df_key.select(["unit", "schedule", "treatment"])
-        selected_df_key_w.group_by(["unit", "schedule"])
-        rows_by_key_df_key = selected_df_key_w.rows_by_key(key=["unit", "schedule"])
-        w_array = np.zeros((selected_df_w["unit"].n_unique(), selected_df_w["schedule"].n_unique()))
-        for i in range(np.shape(w_array)[0]):
-            for j in range(np.shape(w_array)[1]):
-                if len(rows_by_key_df_key[(unique_units[i], j)]) == 0:
-                    continue
-                if (unique_units[i], j) in rows_by_key:
-                    w_array[i][j] = rows_by_key[(unique_units[i], j)][0][1] - rows_by_key[(unique_units[i], j)][0][0]
-    else:
-        selected_df_w = df.filter(pl.col("holding") == holding).select(["unit", "schedule", "stock_2035"])
-        selected_df_w.group_by(["unit", "schedule"])
-        rows_by_key = selected_df_w.rows_by_key(key=["unit", "schedule"])
-        selected_df_key_w = df_key.select(["unit", "schedule", "treatment"])
-        selected_df_key_w.group_by(["unit", "schedule"])
-        rows_by_key_df_key = selected_df_key_w.rows_by_key(key=["unit", "schedule"])
-        w_array = np.zeros((selected_df_w["unit"].n_unique(), selected_df_w["schedule"].n_unique()))
-        for i in range(np.shape(w_array)[0]):
-            for j in range(np.shape(w_array)[1]):
-                if len(rows_by_key_df_key[(unique_units[i], j)]) == 0:
-                    continue
-                if (unique_units[i], j) in rows_by_key:
-                    w_array[i][j] = rows_by_key[(unique_units[i], j)][0][0]
-
-    selected_df_p = df.filter(pl.col("holding") == holding).select(
-        ["unit", "schedule", "harvest_value_period_2025", "harvest_value_period_2030", "harvest_value_period_2035"]
+    df_joined = df.join(df_key, on=["holding", "unit", "schedule"], how="left")
+
+    selected_df = df_joined.filter(pl.col("holding") == holding).select(
+        [
+            "unit",
+            "schedule",
+            "npv_5_percent",
+            "stock_2025",
+            "stock_2035",
+            "harvest_value_period_2025",
+            "harvest_value_period_2030",
+            "harvest_value_period_2035",
+            "treatment",
+        ]
     )
-    selected_df_p.group_by(["unit", "schedule"])
-    rows_by_key = selected_df_p.rows_by_key(key=["unit", "schedule"])
-    p_array = np.zeros((selected_df_p["unit"].n_unique(), selected_df_p["schedule"].n_unique()))
-    for i in range(np.shape(p_array)[0]):
-        for j in range(np.shape(p_array)[1]):
-            if (unique_units[i], j) in rows_by_key:
-                p_array[i][j] = sum(rows_by_key[(unique_units[i], j)][0])
+    unique_units = selected_df.unique(["unit"], maintain_order=True).get_column("unit")
+    n_units = len(unique_units)
+    unique_schedules = selected_df.unique(["schedule"], maintain_order=True).get_column("schedule")
+    n_schedules = len(unique_schedules)
+
+    v_array = np.zeros((n_units, n_schedules))
+    w_array = np.zeros((n_units, n_schedules))
+    p_array = np.zeros((n_units, n_schedules))
+
+    # This is not the fastest way to do this, but the code is probably more understandable
+    for i in range(n_units):
+        for j in range(n_schedules):
+            unit = unique_units[i]
+            schedule = unique_schedules[j]
+            print(f"unit {unit} schedule {schedule}")
+            if selected_df.filter((pl.col("unit") == unit) & (pl.col("schedule") == schedule)).height == 0:
+                continue
+            v_array[i][j] = (
+                selected_df.filter((pl.col("unit") == unit) & (pl.col("schedule") == schedule))
+                .select("npv_5_percent")
+                .item()
+            )
+            w_array[i][j] = (
+                selected_df.filter((pl.col("unit") == unit) & (pl.col("schedule") == schedule))
+                .select("stock_2035")
+                .item()
+            )
+            if comparing:
+                w_array[i][j] -= (
+                    selected_df.filter((pl.col("unit") == unit) & (pl.col("schedule") == schedule))
+                    .select("stock_2025")
+                    .item()
+                )
+            # The harvest values are not going to be discounted like this
+            p_array[i][j] = sum(
+                selected_df.filter((pl.col("unit") == unit) & (pl.col("schedule") == schedule))
+                .select(["harvest_value_period_2025", "harvest_value_period_2030", "harvest_value_period_2035"])
+                .row(0)
+            )
 
     constants = []
     variables = []
@@ -114,25 +122,25 @@ def forest_problem(simulation_results: str, treatment_key: str, holding: int = 1
     f_2_func = []
     f_3_func = []
     # define the constants V, W and P, decision variable X, constraints, and objective function expressions in one loop
-    for i in range(np.shape(v_array)[0]):
+    for i in range(n_units):
         # Constants V, W and P
         v = TensorConstant(
-            name=f"V_{i+1}",
-            symbol=f"V_{i+1}",
+            name=f"V_{i + 1}",
+            symbol=f"V_{i + 1}",
             shape=[np.shape(v_array)[1]],  # NOTE: vectors have to be of form [2] instead of [2,1] or [1,2]
             values=v_array[i].tolist(),
         )
         constants.append(v)
         w = TensorConstant(
-            name=f"W_{i+1}",
-            symbol=f"W_{i+1}",
+            name=f"W_{i + 1}",
+            symbol=f"W_{i + 1}",
             shape=[np.shape(w_array)[1]],  # NOTE: vectors have to be of form [2] instead of [2,1] or [1,2]
             values=w_array[i].tolist(),
         )
         constants.append(w)
         p = TensorConstant(
-            name=f"P_{i+1}",
-            symbol=f"P_{i+1}",
+            name=f"P_{i + 1}",
+            symbol=f"P_{i + 1}",
             shape=[np.shape(p_array)[1]],  # NOTE: vectors have to be of form [2] instead of [2,1] or [1,2]
             values=p_array[i].tolist(),
         )
@@ -140,8 +148,8 @@ def forest_problem(simulation_results: str, treatment_key: str, holding: int = 1
         # Decision variable X
         constants.append(p)
         x = TensorVariable(
-            name=f"X_{i+1}",
-            symbol=f"X_{i+1}",
+            name=f"X_{i + 1}",
+            symbol=f"X_{i + 1}",
             variable_type=VariableTypeEnum.binary,
             shape=[np.shape(v_array)[1]],  # NOTE: vectors have to be of form [2] instead of [2,1] or [1,2]
             lowerbounds=np.shape(v_array)[1] * [0],
@@ -152,10 +160,10 @@ def forest_problem(simulation_results: str, treatment_key: str, holding: int = 1
 
         # Constraints
         con = Constraint(
-            name=f"x_con_{i+1}",
-            symbol=f"x_con_{i+1}",
+            name=f"x_con_{i + 1}",
+            symbol=f"x_con_{i + 1}",
             cons_type=ConstraintTypeEnum.EQ,
-            func=f"Sum(X_{i+1}) - 1",
+            func=f"Sum(X_{i + 1}) - 1",
             is_linear=True,
             is_convex=False,  # not checked
             is_twice_differentiable=True,
@@ -163,13 +171,13 @@ def forest_problem(simulation_results: str, treatment_key: str, holding: int = 1
         constraints.append(con)
 
         # Objective function expressions
-        exprs = f"V_{i+1}@X_{i+1}"
+        exprs = f"V_{i + 1}@X_{i + 1}"
         f_1_func.append(exprs)
 
-        exprs = f"W_{i+1}@X_{i+1}"
+        exprs = f"W_{i + 1}@X_{i + 1}"
         f_2_func.append(exprs)
 
-        exprs = f"P_{i+1}@X_{i+1}"
+        exprs = f"P_{i + 1}@X_{i + 1}"
         f_3_func.append(exprs)
 
     # form the objective function sums

desdeo/problem/testproblems/multi_valued_constraints.py

@@ -0,0 +1,119 @@
+"""Defines a test problem with a constraint that is multi-valued."""
+
+from desdeo.problem import (
+    Constant,
+    Constraint,
+    ConstraintTypeEnum,
+    Objective,
+    ObjectiveTypeEnum,
+    Problem,
+    TensorConstant,
+    TensorVariable,
+    Variable,
+    VariableTypeEnum,
+)
+
+
+def multi_valued_constraint_problem() -> Problem:
+    r"""Defines a test problem with a multi-valued constraint.
+
+     The problem has two objectives, two variables, and two constraints, the other of which, is multi-valued.
+     The problem is defined as follows:
+    \[
+         \begin{aligned}
+         \text{Min} \quad
+         & f_1(x_1, x_2, y) = x_1^2 + x_2^2 + y^2, \\[4pt]
+         \text{Min} \quad
+         & f_2(x_1, x_2, y) = (x_1 - 2)^2 + (x_2 - 1)^2 + (y - 1)^2, \\[6pt]
+         \text{subject to} \quad
+         & g(x_1, x_2, y) = x_1^2 + x_2 + y - 2 \le 0, \\[4pt]
+         & G(x_1, x_2) = A
+         \begin{bmatrix}
+         x_1 \\[2pt]
+         x_2
+         \end{bmatrix}
+         \le 0,
+         \quad
+         A =
+         \begin{bmatrix}
+         1 & -1 \\[2pt]
+         -1 & -2
+         \end{bmatrix}.
+         \end{aligned}
+    \]
+
+
+    Returns:
+         Problem: the problem model.
+    """
+    xs = TensorVariable(
+        name="x",
+        symbol="X",
+        variable_type=VariableTypeEnum.real,
+        shape=[2, 1],
+        lowerbounds=-5.0,
+        upperbounds=5.0,
+        initial_values=0.1,
+    )
+
+    y = Variable(
+        name="y",
+        symbol="y",
+        variable_type=VariableTypeEnum.real,
+        lowerbound=-10.0,
+        upperbound=10.0,
+        initial_value=0.1,
+    )
+
+    a = TensorConstant(name="A", symbol="A", shape=[2, 2], values=[[1.0, -1.0], [-1.0, -2.0]])
+
+    one = Constant(name="one", symbol="one", value=1.0)
+
+    f_1_expr = "X[1, 1]**2 + X[2, 1]**2 + y**2"
+    f_2_expr = "(X[1, 1] - 2)**2 + (X[2, 1] - one)**2 + (y - one)**2"
+
+    g_1_expr = "X[1, 1]**2 + X[2, 1] + y - 2"
+    big_g_expr = "A @ X"
+
+    f_1 = Objective(
+        name="f1",
+        symbol="f_1",
+        func=f_1_expr,
+        objective_type=ObjectiveTypeEnum.analytical,
+        ideal=0.0,
+        nadir=150.0,
+        is_twice_differentiable=True,
+    )
+
+    f_2 = Objective(
+        name="f2",
+        symbol="f_2",
+        func=f_2_expr,
+        ideal=0.0,
+        nadir=206.0,
+        objective_type=ObjectiveTypeEnum.analytical,
+        is_twice_differentiable=True,
+    )
+
+    g_1 = Constraint(
+        name="g1", symbol="g_1", cons_type=ConstraintTypeEnum.LTE, func=g_1_expr, is_twice_differentiable=True
+    )
+
+    big_g = Constraint(
+        name="big_g",
+        symbol="G",
+        cons_type=ConstraintTypeEnum.LTE,
+        func=big_g_expr,
+        is_twice_differentiable=True,
+        is_linear=True,
+        is_convex=True,
+    )
+
+    return Problem(
+        name="Multi-valued-constraint problem",
+        description="Problem for testing problems with multi-valued constraints.",
+        constants=[a, one],
+        variables=[xs, y],
+        constraints=[g_1, big_g],
+        objectives=[f_1, f_2],
+    )