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

desdeo/tools/__init__.py

@@ -0,0 +1,120 @@
+"""Imports available form the desdeo-tools package."""
+
+__all__ = [
+    "BaseSolver",
+    "BonminOptions",
+    "GurobipySolver",
+    "IpoptOptions",
+    "NevergradGenericOptions",
+    "NevergradGenericSolver",
+    "PersistentGurobipySolver",
+    "ProximalSolver",
+    "PyomoBonminSolver",
+    "PyomoCBCSolver",
+    "PyomoGurobiSolver",
+    "PyomoIpoptSolver",
+    "ScalarizationError",
+    "ScipyDeSolver",
+    "ScipyMinimizeSolver",
+    "SolverOptions",
+    "SolverResults",
+    "add_asf_diff",
+    "add_asf_generic_diff",
+    "add_asf_generic_nondiff",
+    "add_asf_nondiff",
+    "add_epsilon_constraints",
+    "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",
+    "add_guess_sf_diff",
+    "add_guess_sf_nondiff",
+    "add_nimbus_sf_diff",
+    "add_nimbus_sf_nondiff",
+    "add_objective_as_scalarization",
+    "add_stom_sf_diff",
+    "add_stom_sf_nondiff",
+    "add_weighted_sums",
+    "available_nevergrad_optimizers",
+    "available_solvers",
+    "find_compatible_solvers",
+    "flip_maximized_objective_values",
+    "get_corrected_ideal_and_nadir",
+    "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,
+)
+from desdeo.tools.ng_solver_interfaces import (
+    NevergradGenericOptions,
+    NevergradGenericSolver,
+    available_nevergrad_optimizers,
+)
+from desdeo.tools.proximal_solver import ProximalSolver
+from desdeo.tools.pyomo_solver_interfaces import (
+    BonminOptions,
+    IpoptOptions,
+    PyomoBonminSolver,
+    PyomoCBCSolver,
+    PyomoGurobiSolver,
+    PyomoIpoptSolver,
+)
+from desdeo.tools.scalarization import (
+    ScalarizationError,
+    add_asf_diff,
+    add_asf_generic_diff,
+    add_asf_generic_nondiff,
+    add_asf_nondiff,
+    add_epsilon_constraints,
+    add_guess_sf_diff,
+    add_guess_sf_nondiff,
+    add_nimbus_sf_diff,
+    add_nimbus_sf_nondiff,
+    add_objective_as_scalarization,
+    add_stom_sf_diff,
+    add_stom_sf_nondiff,
+    add_weighted_sums,
+)
+from desdeo.tools.scipy_solver_interfaces import ScipyDeSolver, ScipyMinimizeSolver
+from desdeo.tools.utils import (
+    available_solvers,
+    find_compatible_solvers,
+    flip_maximized_objective_values,
+    get_corrected_ideal_and_nadir,
+    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

@@ -0,0 +1,165 @@
+"""Defines generic classes, functions, and objects utilized in the tools module."""
+
+from abc import ABC, abstractmethod
+from typing import Any, TypeVar
+
+import polars as pl
+from pydantic import BaseModel, ConfigDict, Field, field_serializer
+
+from desdeo.problem import (
+    Constraint,
+    Objective,
+    Problem,
+    ScalarizationFunction,
+    Variable,
+)
+
+
+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."""
+
+    optimal_variables: dict[str, int | float | list] = Field(description="The optimal decision variables found.")
+    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 | 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."
+        ),
+        default=None,
+    )
+    extra_func_values: dict[str, float | list[float]] | None = Field(
+        description=("The extra function values of the problem."), default=None
+    )
+    scalarization_values: dict[str, float | list[float]] | None = Field(
+        description=("The scalarization function values of the problem."), default=None
+    )
+    success: bool = Field(description="A boolean flag indicating whether the optimization was successful or not.")
+    message: str = Field(description="Description of the cause of termination.")
+
+
+class BaseSolver(ABC):
+    """Defines a schema for a solver base class."""
+
+    evaluator: object
+    problem: Problem
+
+    def __init__(self, problem: Problem, options: dict[str, any] | None = None):
+        """Initializer for the persistent solver.
+
+        Args:
+            problem (Problem): The problem for the solver.
+            options (dict[str,any]): Dictionary of parameters to set.
+                What these should be depends on the solver used.
+        """
+        self.problem = problem
+
+    @abstractmethod
+    def solve(self, target: str) -> SolverResults:
+        """Solves the current problem with the specified target.
+
+        Args:
+            target (str): a str representing the symbol of the target function.
+
+        Returns:
+            SolverResults: The results of the solver
+        """
+
+
+class PersistentSolver:
+    """Defines a schema for a persistent solver class.
+
+    Can be used when reinitializing the solver every time the problem is changed is not practical.
+    """
+
+    evaluator: object
+    problem: Problem
+
+    def __init__(self, problem: Problem, options: dict[str, any] | None = None):
+        """Initializer for the persistent solver.
+
+        Args:
+            problem (Problem): The problem for the solver.
+            options (dict[str,any]): Dictionary of parameters to set.
+                What these should be depends on the solver used.
+        """
+        self.problem = problem
+
+    def add_constraint(self, constraint: Constraint | list[Constraint]):
+        """Add a constraint expression to the solver.
+
+        Args:
+            constraint (Constraint): the constraint function expression.
+        """
+
+    def add_objective(self, objective: Objective):
+        """Adds an objective function expression to the solver.
+
+        Args:
+            objective (Objective): an objective function expression to be added.
+        """
+
+    def add_scalarization_function(self, scalarization: ScalarizationFunction):
+        """Adds a scalrization expression to the solver.
+
+        Args:
+            scalarization (ScalarizationFunction): A scalarization function to be added.
+        """
+
+    def add_variable(self, variable: Variable):
+        """Add a variable to the solver.
+
+        Args:
+            variable (Variable): The definition of the variable to be added.
+        """
+
+    def remove_constraint(self, symbol: str):
+        """Removes a constraint from the solver.
+
+        Args:
+            symbol (str): a str representing the symbol of the constraint to be removed.
+        """
+
+    def remove_variable(self, symbol: str):
+        """Removes a variable from the model.
+
+        Args:
+            symbol (str): a str representing the symbol of the variable to be removed.
+        """
+
+    def solve(self, target: str) -> SolverResults:
+        """Solves the current problem with the specified target.
+
+        Args:
+            target (str): a str representing the symbol of the target function.
+
+        Returns:
+            SolverResults: The results of the solver
+        """
+
+
+SolverOptions = TypeVar("SolverOptions", bound=Any)