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

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],
+    )

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,