Multiobjective Optimization

multOpt: multiobjective optimization

This subpackage contains scalarization methods to solve (possibly box-constrained) multiobjective optimization problems of the form

\[\min (f_1(x), \ldots, f_k(x)),\]

\[\text{s. t. } x_a \leq x \leq x_b.\]

The general idea of scalarization methods is to transform the multiobjective optimization problem into a series of scalar optimization problems. which can then be solved by using methods from unconstrained or constrained optimization (see the subpackages unconOpt or conOpt). The three existing scalarizaton methods are the weighted-sum method (WSM), the Euclidean reference point method (ERPM) and the Pascoletti-Serafini method (PSM).

Documentation is available in the docstrings and online here.

Methods

oppy.multOpt.mop module

Multiobjective optimization problem solver.

This module contains method to solve (possibly box-constrained) multiobjective optimization problems with arbitrarily many cost functions of the form

\[\min (f_1(x), \ldots, f_k(x)),\]

\[\text{s. t. } x_a \leq x \leq x_b,\]

by a scalarization method, which can either be the weighted-sum method, the Euclidean reference point method or the Pascoletti-Serafini method. The idea of the algorithm for the Euclidean reference point method and the Pascoletti-Serafini method is to hierarchically solve subproblems of the multiobjective optimization problems, i.e., multiobjective optimization problems, which consider only a subset of all cost functions. When solving a subproblem, the information of all previously solved subproblems of this subproblem are used to create the necessary parameters for the Euclidean reference point method and the Pascoletti-Serafini method, respectively. For consistency, the weighted-sum method also hierarchically solves subproblems, although for this method, the required parameters could be computed already in the beginning of the optimization.

In general and from a theoretical point of view, the weighted-sum method and the Euclidean reference point method can only solve convex multiobjective optimization problems, whereas the Pascoletti-Serafini method is also well-suited for non-convex problems.

The advantage of the Euclidean reference point method over the weighted-sum method is that one has a guaranteed approximation fineness of the Pareto front, which is specified by the grid size hx, whereas the approximation of the Pareto front by the weighted-sum method might have larger gaps.

Note that even though the Pascoletti-Serafini method is in principle capable of solving non-convex problems, the quality of the result strongly depends on computing the global minimizer of the arising Pascoletti-Serafini method, which can in general not be guaranteed when using local optimization methods.

If the problem is non-convex (i.e., at least one of the cost functions is non-convex), this can be specified in the options. In this case, the three methods heuristically try to increase the probability of computing the global minimizer of the arising scalarized optimization problems by solving each of them twice with different initial values.

oppy.multOpt.mop.solve_MultiobjectiveOptimizationProblem(fhandle, dfhandle, x, low, up, options=None, ddfhandle=None)

Solver for general multiobjective optimization problems.

This method solves a given multiobjective optimization problem by a specified scalarization method (either the weighted-sum method, the Euclidean reference point method or the Pascoletti-Serafini method).

Parameters:

fhandle (list of callable(), length k) –
The list of length k containing the objective functions to be minimized. For the i-th entry of the list with \(0 \leq i \leq k-1\) we have

fhandle[i](x, *fargs) -> float

where x is an 1-D array with shape (n,) and args is a tuple of the fixed parameters needed to completely specify the function.
dfhandle (list of callable(), length k) –
The list of length k containing the gradients of the objective functions. For the i-th entry with \(0 \leq i \leq k-1\) we have

dfhandle[i](x, *fargs) -> array_like, shape (n,).

where x is an 1-D array with shape (n,) and fargs is a tuple of the fixed parameters needed to completely specify the function.
x (numpy.ndarray, shape (n,)) – Initial guess for solving the scalar optimization problems of all individual cost functions. Array of real elements of size (n,), where ‘n’ is the number of independent variables.
low (numpy.ndarray, shape (n,)) – Lower bound. Array of real elements of size (n,), where ‘n’ is the number of independent variables.
up (numpy.ndarray, shape (n,)) – Upper bound. Array of real elements of size (n,), where ‘n’ is the number of independent variables.
options (Options, optional) –
Options for the weighted-sum method method, represented as a Options object. The default is None. Options for the multiobjective optimization are:
- mop_methodstr
  
  Scalarization method, with which the multiobjective optimization problem is supposed to be solved. Possible choices are “WSM”, “ERPM” and “PSM”, initialized with “WSM”.
- num_weights_per_dimensionint
  
  If mop_method == “WSM”: Number of weights per dimension used for the discretization of the set of weights. Initialized with \(20\).
- r_PSMnumpy.ndarray, shape (k,)
  
  If mop_method == “PSM”: Target direction r for the Pascoletti-Serafini problem. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem, initialized with np.ones(k).
- hpfloat
  
  If mop_method == (“ERPM” or “PSM”): Shifting value for the coordinate axis containing the reference points, initialized with \(1\).
- hxfloat
  
  If mop_method == (“ERPM” or “PSM”): Grid size of the reference point grid, initialized with \(0.5\).
- WSM_optimethcallable()
  
  Callable function that solves the weighted-sum problems, initialized with gradmethod.
- ERPM_optimethcallable()
  
  If mop_method == “ERPM”: Callable function that solves the Euclidean reference point problems, initialized with gradmethod.
- PSM_optimethcallable()
  
  If mop_method == “PSM”: Callable function that solves the Pascoletti-Serafini problems, initialized with the augmented Lagrangian method.
- problem_typestr
  
  Indicates if the problem is convex or non-convex. The string can either contain “convex” or “non-convex”, initialized with “convex”.
ddfhandle (list of callable(), length k, optional) –
The list of length k containing the Hessians of the objective functions. Only required if the optimizer is a second order method. Therefore, the default is None. Otherwise, for the i-th entry of the list with \(0 \leq i \leq k-1\) we have

ddfhandle[i](x, *fargs) -> array_like, shape (n,n).

where x is an 1-D array with shape (n,) and args is a tuple of the fixed parameters needed to completely specify the function.

Returns:

MOP (dict) – Dictionary containing the solutions to the multiobjective optimization problem. Its keys are given by the strings of all subproblems and the problem itself, e.g., the key “1,2” stands for the subproblem with the cost functions \(f_1\) and \(f_2\). Each of the values corresponding to such a key is a dictionary itself and contains the following keys:
- ”Results”list of Results, length num_sol
  
  List of instances of the class Results with length num_sol, where num_sol is the number of computed Pareto optimal points of the current subproblem. Represents the optimization results. Attributes of the object depend on the choice of the options.results parameter. With default choice the object has the following attributes:
  
  xnumpy.ndarray, shape (n,)
  
  Solution vector of the optimization problem.
  
  iterationsscalar
  
  Number of iterations the algorithm needed.
  
  reslist
  
  List with the norm of the residuals.
- ”func_values”numpy.ndarray, shape (num_sol, k)
  
  Pareto optimal function values of the current subproblem. Array of size (num_sol, k), where ‘num_sol’ is the number of computed Pareto optimal points of the current subproblem and ‘k’ is the number of total cost functions of the MOP.
- ”x”numpy.ndarray, shape (num_sol, n)
  
  Pareto optimal points of the current subproblem. Array of size (num_sol, n), where ‘num_sol’ is the number of computed Pareto optimal points of the current subproblem and ‘n’ is the number of independent variables.
- ”t”numpy.ndarray, shape (num_sol,)
  
  For the PSM: Optimal max-values of the computed Pareto-optimal points. Array of size (num_sol,), where ‘num_sol’ is the number of computed Pareto optimal points of the current subproblem.
- ”alpha”numpy.ndarray, shape (num_alpha, k_current)
  
  For the WSM: Weight vectors for the current subproblem. Array of size (num_alpha, k_current), where ‘num_alpha’ is the number of weight vectors and k_current is the number of cost functions of the current subproblem.
- ”alpha_all”numpy.ndarray, shape (num_alpha, k)
  
  For the WSM: Weight vectors for the current subproblem seen as weights of the entire MOP. Created by adding 0s to the weights from ‘alpha’ in the respective dimensions. Array of size (num_alpha, k), where ‘num_alpha’ is the number of weight vectors and ‘k’ is the number of cost function of the entire multiobjective optimization problem.
- ”z_ref”numpy.ndarray, shape (num_z_ref, k_current)
  
  For the ERPM and the PSM: Reference points for the current subproblem. Array of size (num_z_ref, k_current), where ‘num_z_ref’ is the number of referece points and k_current is the number of cost functions of the current subproblem.
- ”z_ref_all”numpy.ndarray, shape (num_z_ref, k)
  
  For the ERPM and the PSM: Reference points for the current subproblem seen as reference points of the entire multiobjective optimization problem. Created by adding the function values of the non-involved cost functions to the reference points from “z_ref” in the respective dimensions. Array of size (num_z_ref, k), where ‘num_z_ref’ is the number of reference points and ‘k’ is the number of cost function of the entire multiobjective optimization problem.
data (dict) – Dictionary containing additional data of the multiobjective optimization problem. In comparison to the input, the key corresponding to the current subproblem has been added. The value of this key is a dictionary itself and contains the following key:
- ”ynad”numpy.ndarray, shape (k,)
  
  Nadir point of the current subproblem w.r.t. all cost functions. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
- ”z_ref_create”list
  
  Information about the reference points of the current subproblem, which are needed to create reference points for all superproblems of the current subproblem. Each entry of the list is a dictionary and corresponds to a reference points. It has the following (key,value) pairs:
  
  ”Coordinates”numpy.ndarray, shape (k,)
  
  Coordinates of the current reference point w.r.t. all cost functions (see z_ref_all in MOP). Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
  
  ”Boxnumber”numpy.ndarray of int, shape (k,)
  
  Specifies the box on the shifted coordinate plane that the current reference point lies in. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
  
  ”Subproblem”str
  
  The subproblem to which the current reference point belongs, written as a string (e.g, the string “1,2” stands for the subproblem with the cost functions \(f_1\) and \(f_2\)).
  
  ”Missing_CFs”str
  
  The missing cost functions that are not part of the current subproblem written as a string (e.g., the string “3,4” means that the cost functions \(f_3\) and \(f_4\) are not part of the current subproblem).
  
  ”Coordinate_Plane”str
  
  Index of the coordinate plane that the current reference point lies on written as a string.

References

M. Ehrgott. Multicriteria Optimization. Springer, Berlin, Heidelberg, Second Edition, 2005, see Ehrgott [Ehr05].

J. Jahn. Vector Optimization. Springer, Berlin, Heidelberg, Second Edition, 2011, see Jahn and others [J+11].

A. Pascoletti and P. Serafini. Scalarizing Vector Optimization Problems. Journal of Optimization Theory and Applications, 42(4):499–524, 1984, see Pascoletti and Serafini [PS84].

A.P. Wierzbicki. The Use of Reference Objectives in Multiobjective Optimization. Multiple Criteria Decision Making Theory and Application, 468–486, 1980, see Wierzbicki [Wie80].

L. Zadeh. Optimality and Non-Scalar-Valued Performance Criteria. IEEE Transactions on Automatic Control, 8(1):59–60, 1963, see Zadeh [Zad63].

Examples

Multiobjective optimization of two parabolas

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from oppy.options import Options
>>> from oppy.multOpt.mop import solve_MultiobjectiveOptimizationProblem

Define the cost functions and their gradients

>>> f1 = (lambda x: (x[0] - 1)**2 + (x[1] - 1)**2)
>>> f2 = (lambda x: (x[0] + 0.5)**2 + (x[1] + 1)**2)
>>> df1 = (lambda x: np.array([2*(x[0] - 1), 2*(x[1] - 1)]))
>>> df2 = (lambda x: np.array([2*(x[0] + 0.5), 2*(x[1] + 1)]))

Store the cost functions, their gradients and Hessians in a list

>>> f = [f1, f2]
>>> df = [df1, df2]

No box constraints

>>> low = np.array([-np.Inf, -np.Inf])
>>> up = np.array([np.Inf, np.Inf])

Specify the initial value

>>> x0 = np.array([0, 0])

Options for the weighted sum method

>>> options_WSM = Options(mop_method="WSM", num_weights_per_dimension=30)

Options for the Euclidean reference point method

>>> options_ERPM = Options(mop_method="ERPM", hp=0.2, hx=0.5)

Options for the Pascoletti-Serafini method

>>> options_PSM = Options(mop_method="PSM", hp=0.2, hx=0.5,
>>>                       r_PSM=np.ones(len(f)))

Execute the multiobjective optimization:

For the weighed-sum method

>>> MOP_WSM, data_WSM = solve_MultiobjectiveOptimizationProblem(
>>>                         f, df, x0, low, up, options=options_WSM
>>>                                                             )

For the Euclidean reference point method

>>> MOP_ERPM, data_ERPM = solve_MultiobjectiveOptimizationProblem(
>>>                         f, df, x0, low, up, options=options_ERPM
>>>                                                               )

For the Pascoletti-Serafini method

>>> MOP_PSM, data_PSM = solve_MultiobjectiveOptimizationProblem(
>>>                         f, df, x0, low, up, options=options_PSM
>>>                                                             )

Get the optimal solutions

>>> x_opt_WSM = MOP_WSM["1,2"].x
>>> x_opt_ERPM = MOP_ERPM["1,2"].x
>>> x_opt_PSM = MOP_PSM["1,2"].x

Plot the obtained approximations of the Pareto set

>>> fig = plt.figure()
>>> plt.plot(x_opt_WSM[:, 0], x_opt_WSM[:, 1], 'o')
>>> plt.plot(np.array([1, -0.5]), np.array([1, -1]))
>>> plt.title('Weighted-Sum Method')
>>> fig = plt.figure()
>>> plt.plot(x_opt_ERPM[:, 0], x_opt_ERPM[:, 1], 'o')
>>> plt.plot(np.array([1, -0.5]), np.array([1, -1]))
>>> plt.title('Euclidean Reference Point Method')
>>> fig = plt.figure()
>>> plt.plot(x_opt_PSM[:, 0], x_opt_PSM[:, 1], 'o')
>>> plt.plot(np.array([1, -0.5]), np.array([1, -1]))
>>> plt.title('Pascoletti-Serafini Method')

The exact Pareto set is the line between the two vertices [1,1] and [-0.5,-1]. One can see that for all three methods, the results are approximating the exact Pareto set, which is plotted in orange, very well.

oppy.multOpt.erpm module

Euclidean reference point method.

oppy.multOpt.erpm.erpm(fhandle, dfhandle, x, low, up, MOP, data, options, ddfhandle=None)

Euclidean reference point method.

This method solves a given subproblem (potentially the entire problem) of a given multiobjective optimization problem by the Euclidean reference point method. It uses information from already solved subproblems of the current subproblem to create the refernce points for the current subproblem. For all created reference points z, the Euclidean reference point problem

\[\min_x \sum_{i=1}^k \frac{1}{2} (f_i(x) - z_i)^2\]

\[\text{s. t. } \text{low} \leq x \leq \text{up}\]

is solved by using an optimziation method for constrained optimization, which is specified in the options.

Parameters:

fhandle (list of callable(), length k) –
The list of length k containing the objective functions of the entire multiobjective optimization problem. Note that not all of them might be considered, but only those who are part of the current subproblem specified in data. For the i-th entry of the list with \(0 \leq i \leq k-1\) we have

fhandle[i](x, *fargs) -> float

where x is an 1-D array with shape (n,) and args is a tuple of the fixed parameters needed to completely specify the function.
dfhandle (list of callable(), length k) –
The list of length k containing the gradients of the entire multiobjective optimization problem. Note that not all of them might be considered, but only those who are part of the current subproblem specified in data. For the i-th entry with \(0 \leq i \leq k-1\) we have

dfhandle[i](x, *fargs) -> array_like, shape (n,).

where x is an 1-D array with shape (n,) and fargs is a tuple of the fixed parameters needed to completely specify the function.
x (numpy.ndarray, shape (n,)) – Initial guess for solving the scalar optimization problems. Array of real elements of size (n,), where ‘n’ is the number of independent variables.
low (numpy.ndarray, shape (n,)) – Lower bound. Array of real elements of size (n,), where ‘n’ is the number of independent variables.
up (numpy.ndarray, shape (n,)) – Upper bound. Array of real elements of size (n,), where ‘n’ is the number of independent variables.
MOP (dict) –
Dictionary containing the solutions to the multiobjective optimization problem. It conatins keys given by the strings of all already solved subproblems, e.g., it contains the key “1,2”, if the subproblem with the cost functions \(f_1\) and \(f_2\) has already been solved. Each of the alues corresponding to such a key is a dictionary itself and contains the following keys:
- ”Results”list of Results, length num_sol
  
  List of instances of the class Results with length num_sol, where num_sol is the number of Pareto optimal points of the current subproblem. Represents the optimization results. Attributes of the object depend on the choice of the options.results parameter. With default choice the object has the following attributes:
  
  xnumpy.ndarray, shape (n,)
  
  Solution vector of the optimization problem.
  
  iterationsint
  
  Number of iterations the algorithm needed.
  
  reslist
  
  List with the norm of the residuals.
- ”func_values”numpy.ndarray, shape (num_sol, k)
  
  Pareto optimal function values of the current subproblem. Array of size (num_sol, k), where ‘num_sol’ is the number of Pareto optimal points of the current subproblem and ‘k’ is the number of total cost functions of the MOP.
- ”x”numpy.ndarray, shape (num_sol, n)
  
  Pareto optimal points of the current subproblem. Array of size (num_sol, n), where ‘num_sol’ is the number of Pareto optimal points of the current subproblem and ‘n’ is the number of independent variables.
- ”z_ref”numpy.ndarray, shape (num_z_ref, k_current)
  
  Reference points for the current subproblem. Array of size (num_z_ref, k_current), where ‘num_z_ref’ is the number of referece points and k_current is the number of cost functions of the current subproblem.
- ”z_ref_all”numpy.ndarray, shape (num_z_ref, k)
  
  Reference points for the current subproblem seen as reference points of the entire multiobjective optimization problem. Created by adding the function values of the non-involved cost functions to the reference points from “z_ref” in the respective dimensions. Array of size (num_z_ref, k), where ‘num_z_ref’ is the number of reference points and ‘k’ is the number of cost function of the entire multiobjective optimization problem.
data (dict) –
Dictionary containing additional data of the multiobjective optimization problem. It contains keys given by the strings of all already solved subproblems, e.g., it contains the key “1,2”, if the subproblem with the cost functions \(f_1\) and \(f_2\) has already been solved.
- ”1,2”dict
  
  Dictionary containing the keys
  
  ”ynad”numpy.ndarray, shape (k,)
  
  Nadir point of the subproblem “1,2” w.r.t. all cost functions. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
  
  ”z_ref_create”list
  
  Information about the reference points of the current subproblem, which are needed to create reference points for all superproblems of the current subproblem. Each entry of the list is a dictionary and corresponds to a reference points. It has the following (key,value) pairs:
  
  ”Coordinates”numpy.ndarray, shape (k,)
  
  Coordinates of the current reference point w.r.t. all cost functions (see z_ref_all in MOP). Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
  
  ”Boxnumber”numpy.ndarray of int, shape (k,)
  
  Specifies the box on the shifted coordinate plane that the current reference point lies in. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
  
  ”Subproblem”str
  
  The subproblem to which the current reference point belongs, written as a string (e.g, the string “1,2” stands for the subproblem with the cost functions \(f_1\) and \(f_2\)).
  
  ”Missing_CFs”str
  
  The missing cost functions that are not part of the current subproblem written as a string (e.g., the string “3,4” means that the cost functions f_3 and f_4 are not part of the current subproblem).
  
  ”Coordinate_Plane”str
  
  Index of the coordinate plane that the current reference point lies on written as a string.
Additionally, data contains the following keys:
- ”yid”numpy.ndarray, shape (k,)
  
  Ideal point of the multiobjective optimization problem. Array of size (k,), where ‘k’ is the nunmber of cost functions of the entire multiobjective optimization problem. The value of each entry is given by the minimal value of the corresponding cost function.
- ”yidshift”numpy.ndarray, shape (k,)
  
  Shifted ideal point of the multiobjective optimization problem. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem. The shifted ideal point is given by yid - d, where d is the specified shifting vector of the problem.
- ”current_subproblem”tuple, length num_current_sp
  
  Tuple containing the indices of the cost functions involved in the current subproblem. Tuple of length num_current_sp, where 'num_current_sp' is the number of cost functions in the current subproblem.
options (Options, optional) –
Options for the weighted-sum method method, represented as a Options object. The default is None. Possible/Relevant options for the Euclidean reference point method are:
- mop_methodstr
  
  Scalarization method, with which the multiobjective optimization problem is supposed to be solved. Possible choices are “WSM”, “ERPM” and “PSM”. This method is only called, if the method is "ERPM".
- hpfloat
  
  Shifting value for the coordinate axis containing the reference points.
- hxfloat
  
  Grid size of the reference point grid.
- ERPM_optimethcallable()
  
  Callable function that solves the Euclidean reference point problems, initialized with gradmethod.
- problem_typestr
  
  Indicates if the problem is convex or non-convex. The string can either contain “convex” or “non-convex”, initialized with “convex”.
ddfhandle (list of callable(), length k, optional) –
The list of length k containing the Hessians of the objective functions. Only required if the optimizer is a second order method. Therefore, the default is None. Otherwise, note that not all of them might be considered, but only those who are part of the current subproblem specified in data. For the i-th entry of the list with \(0 \leq i \leq k-1\) we have

ddfhandle[i](x, *fargs) -> array_like, shape (n,n).

where x is an 1-D array with shape (n,) and args is a tuple of the fixed parameters needed to completely specify the function.

Returns:

MOP (dict) – Dictionary containing the solutions to the multiobjective optimization problem. In addition to the input, the key corresponding to the current subproblem has been added. The value of this key is a dictionary itself and contains the following keys:
- ”Results”list of Results, length num_sol
  
  List of instances of the class Results with length num_sol, where num_sol is the number of Pareto optimal points of the current subproblem. Represents the optimization results. Attributes of the object depend on the choice of the options.results parameter. With default choice the object has the following attributes:
  
  xnumpy.ndarray, shape (n,)
  
  Solution vector of the optimization problem.
  
  iterationsint
  
  Number of iterations the algorithm needed.
  
  reslist
  
  List with the norm of the residuals.
- ”func_values”numpy.ndarray, shape (num_sol, k)
  
  Pareto optimal function values of the current subproblem. Array of size (num_sol, k), where ‘num_sol’ is the number of Pareto optimal points of the current subproblem and ‘k’ is the number of total cost functions of the MOP.
- ”x”numpy.ndarray, shape (num_sol, n)
  
  Pareto optimal points of the current subproblem. Array of size (num_sol, n), where ‘num_sol’ is the number of Pareto optimal points of the current subproblem and ‘n’ is the number of independent variables.
- ”z_ref”numpy.ndarray, shape (num_z_ref, k_current)
  
  Reference points for the current subproblem. Array of size (num_z_ref, k_current), where ‘num_z_ref’ is the number of referece points and k_current is the number of cost functions of the current subproblem.
- ”z_ref_all”numpy.ndarray, shape (num_z_ref, k)
  
  Reference points for the current subproblem seen as reference points of the entire multiobjective optimization problem. Created by adding the function values of the non-involved cost functions to the reference points from “z_ref” in the respective dimensions. Array of size (num_z_ref, k), where ‘num_z_ref’ is the number of reference points and ‘k’ is the number of cost function of the entire multiobjective optimization problem.
data (dict) – Dictionary containing additional data of the multiobjective optimization problem. In comparison to the input, the key corresponding to the current subproblem has been added. The value of this key is a dictionary itself and contains the following keys:
- ”ynad”numpy.ndarray, shape (k,)
  
  Nadir point of the current subproblem w.r.t. all cost functions. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
- ”z_ref_create”list
  
  Information about the reference points of the current subproblem, which are needed to create reference points for all superproblems of the current subproblem. Each entry of the list is a dictionary and corresponds to a reference points. It has the following (key,value) pairs:
  
  ”Coordinates”numpy.ndarray, shape (k,)
  
  Coordinates of the current reference point w.r.t. all cost functions (see z_ref_all in MOP). Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
  
  ”Boxnumber”numpy.ndarray of int, shape (k,)
  
  Specifies the box on the shifted coordinate plane that the current reference point lies in. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
  
  ”Subproblem”str
  
  The subproblem to which the current reference point belongs, written as a string (e.g, the string “1,2” stands for the subproblem with the cost functions \(f_1\) and \(f_2\)).
  
  ”Missing_CFs”str
  
  The missing cost functions that are not part of the current subproblem written as a string (e.g., the string “3,4” means that the cost functions \(f_3\) and \(f_4\) are not part of the current subproblem).
  
  ”Coordinate_Plane”str
  
  Index of the coordinate plane that the current reference point lies on written as a string.

References

S. Banholzer. ROM-Based Multiobjective Optimization with PDE Constraints. PhD Thesis, 2021, see Banholzer [Ban21].

S. Banholzer and S. Volkwein. Hierarchical Convex Multiobjective Optimization by the Euclidean Reference Point Method. Techincal Report, 2019, see Banholzer and Volkwein [BV19].

K.M. Miettinen. Nonlinear Multiobjective Optimization. Kluwer Academic Publishers, AH Dordrecht, First Edition, 1999, see Miettinen [Mie99].

A.P. Wierzbicki. The Use of Reference Objectives in Multiobjective Optimization. Multiple Criteria Decision Making Theory and Application, 468–486, 1980, see Wierzbicki [Wie80].

A.P. Wierzbicki. On the Completeness and Constructiveness of Parametric Characterizations to Vector Optimization Problems. Operations-Researh-Spektrum, 8(2):73–87, 1986, see Wierzbicki [Wie86].

A.P. Wierzbicki. Reference Point Methods in Vector Optimziation and Decision Support. IIASA Interim Report, 1998, see Wierzbicki [Wie98].

oppy.multOpt.erpm.create_reference_points(data, options)

Create the reference points for the Euclidean reference point method.

This method creates the reference points for the Euclidean reference point method by using information of the solutions of all subproblems of the current problem.

Parameters:	data (`dict`) – Dictionary containing additional data of the multiobjective optimization problem. It contains keys given by the strings of all already solved subproblems, e.g., it contains the key “1,2”, if the subproblem with the cost functions \(f_1\) and \(f_2\) has already been solved. ”1,2”`dict` Dictionary containing the keys ”ynad”`numpy.ndarray`, shape (k,) Nadir point of the subproblem “1,2” w.r.t. all cost functions. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem. ”z_ref_create”`list` Information about the reference points of the current subproblem, which are needed to create reference points for all superproblems of the current subproblem. Each entry of the list is a dictionary and corresponds to a reference points. It has the following (key,value) pairs: ”Coordinates”`numpy.ndarray`, shape (k,) Coordinates of the current reference point w.r.t. all cost functions (see z_ref_all in MOP). Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem. ”Boxnumber”`numpy.ndarray` of `int`, shape (k,) Specifies the box on the shifted coordinate plane that the current reference point lies in. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem. The subproblem to which the current reference point belongs, written as a string (e.g, the string “1,2” stands for the subproblem with the cost functions \(f_1\) and \(f_2\)). ”Missing_CFs”`str` The missing cost functions that are not part of the current subproblem written as a string (e.g., the string “3,4” means that the cost functions \(f_3\) and \(f_4\) are not part of the current subproblem). ”Coordinate_Plane”`str` Index of the coordinate plane that the current reference point lies on written as a string. Additionally, data contains the following keys: ”yid”`numpy.ndarray`, shape (k,) Ideal point of the multiobjective optimization problem. Array of size (k,), where ‘k’ is the nunmber of cost functions of the entire multiobjective optimization problem. The value of each entry is given by the minimal value of the corresponding cost function. ”yidshift”`numpy.ndarray`, shape (k,) Shifted ideal point of the multiobjective optimization problem. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem. The shifted ideal point is given by yid - d, where d is the specified shifting vector of the problem. ”current_subproblem”`tuple`, length num_current_sp Tuple containing the indices of the cost functions involved in the current subproblem. Tuple of length num_current_sp, where ‘num_current_sp’ is the number of cost functions in the current subproblem. options (`Options`, optional) – Options for the Euclidean reference point method, represented as a `Options` object. The default is `None`. Possible/Relevant options for the creation of the reference points are: hp`float` Shifting value for the coordinate axis containing the reference points. hx`float` Grid size of the reference point grid.
Returns:	z_ref – Created reference point for the current subproblem. Array of size (num_z_ref, num_current_sp), where ‘num_z_ref’ is the number of reference points and num_current_sp is the number of cost functions of the current subproblem.
Return type:	`numpy.ndarray`, shape (num_z_ref, num_current_sp)

oppy.multOpt.erpm.create_z_ref_grid(interval_list)

Create the reference point grid for the current subproblem.

This method creates the reference point grid on the shifted coordinate planes.

Parameters:	interval_list (`list`, length num_current_sp) – List of reference point grids of the individual cost functions that are part of the current subproblem. The length of the list is num_current_sp, which is the number of the cost functions of the current subproblem. Each entry of the list is an array containing the reference point grid for the respective cost function.
Returns:	z_ref_grid – Reference point grid on the shifted coordinate planes. Array of size (num_z_ref_grid, num_current_sp), where ‘num_z_ref_grid’ is the number of reference points on the grid and ‘num_current_sp’ is the number of cost functions of the current subproblem.
Return type:	`numpy.ndarray`, shape (num_z_ref_grid, num_current_sp)

oppy.multOpt.erpm.evalFunc_ERPM(fhandle, x, z)

Evaluate the Euclidean reference point function.

This method evaluates the Euclidean reference point function given the point x and the reference point z.

Parameters:	fhandle (`list` of `callable()`, length num_costfun) – The list containing the objective functions of the considered Euclidean reference point function. For the i-th entry of the list with \(0 \leq i \leq \text{num_costfun} - 1\), we have `fhandle[i](x, *fargs) -> float` where x is an 1-D array with shape (n,) and args is a tuple of the fixed parameters needed to completely specify the function. x (`numpy.ndarray`, shape (n,)) – Current value of the variable. Array of real elements of size (n,), where ‘n’ is the number of independent variables. z (`numpy.ndarray`, shape (num_costfun,)) – Reference point of the Euclidean reference point function. Array of size (num_costfun,), where ‘num_costfun’ is the number of cost functions.
Returns:	func_val – Function value of the Euclidean reference point function.
Return type:	`float`

oppy.multOpt.erpm.evalGrad_ERPM(fhandle, dfhandle, x, z)

Evaluate the gradient of the Euclidean reference point function.

This method evaluates the gradient of the Euclidean reference point function given the point x and the reference point z.

Parameters:	fhandle (`list` of `callable()`, length num_costfun) – The list containing the objective functions of the considered Euclidean reference point function. For the i-th entry of the list with \(0 \leq i \leq \text{num_costfun} - 1\), we have `fhandle[i](x, fargs) -> float` where x is an 1-D array with shape (n,) and args is a tuple of the fixed parameters needed to completely specify the function. dfhandle* (`list` of `callable()`, length num_costfun) – The list containing the gradients of the objective functions of the considered Euclidean reference point function. For the i-th entry of the list with \(0 \leq i \leq \text{num_costfun} - 1\), we have `dfhandle[i](x, *fargs) -> array_like, shape (n,).` where x is an 1-D array with shape (n,) and fargs is a tuple of the fixed parameters needed to completely specify the function. x (`numpy.ndarray`, shape (n,)) – Current value of the variable. Array of real elements of size (n,), where ‘n’ is the number of independent variables. z (`numpy.ndarray`, shape (num_costfun,)) – Reference point of the Euclidean reference point function. Array of size (num_costfun,), where ‘num_costfun’ is the number of cost functions.
Returns:	grad_val – Gradient of the Euclidean reference point function at the point x. Array of size (n,), where ‘n’ is the number of independent variables.
Return type:	`numpy.ndarray`, shape (n,)

oppy.multOpt.erpm.evalHess_ERPM(fhandle, dfhandle, ddfhandle, x, z)

Evaluate the Hessian of the Euclidean reference point function.

This method evaluates the Hessian of the Euclidean reference point function given the point x and the reference point z.

Parameters:	fhandle (`list` of `callable()`, length num_costfun) – The list containing the objective functions of the considered Euclidean reference point function. For the i-th entry of the list with \(0 \leq i \leq \text{num_costfun} - 1\), we have `fhandle[i](x, fargs) -> float` where x is an 1-D array with shape (n,) and args is a tuple of the fixed parameters needed to completely specify the function. dfhandle* (`list` of `callable()`, length num_costfun) – The list containing the gradients of the objective functions of the considered Euclidean reference point function. For the i-th entry of the list with \(0 \leq i \leq \text{num_costfun} - 1\), we have `dfhandle[i](x, fargs) -> array_like, shape (n,).` where x is an 1-D array with shape (n,) and fargs is a tuple of the fixed parameters needed to completely specify the function. ddfhandle* (`list` of `callable()`, length num_costfun) – The list containing the Hessians of the objective functions of the considered Euclidean reference point function. For the i-th entry of the list with \(0 \leq i \leq \text{num_costfun} - 1\), we have `ddfhandle[i](x, *fargs) -> array_like, shape (n,n).` where x is an 1-D array with shape (n,) and args is a tuple of the fixed parameters needed to completely specify the function. x (`numpy.ndarray`, shape (n,)) – Current value of the variable. Array of real elements of size (n,), where ‘n’ is the number of independent variables. z (`numpy.ndarray`, shape (num_costfun,)) – Reference point of the Euclidean reference point function. Array of size (num_costfun,), where ‘num_costfun’ is the number of cost functions.
Returns:	hess_val – Hessian of the Euclidean reference point function at the point x. Array of size (n,n), where ‘n’ is the number of independent variables.
Return type:	`numpy.ndarray`, shape (n,n)

oppy.multOpt.handle_subproblems module

Helper functions for multiobjective optimization.

This module contains helper functions for handling the subproblems of a multiobjective optimization problem.

oppy.multOpt.handle_subproblems.get_involved_cfs_string(problem_string)

Get a list of strings containing single numbers.

Parameters:	problem_string (`str`) – Contains the numbers of the involved cost functions separated by a comma as a string , e.g., “1,2” for the subproblem with the cost functions \(f_1\) and \(f_2\).
Returns:	single_string_list – List of strings containing the numbers of the involved cost functions. For the above example: [“1”, “2”]
Return type:	`list`

oppy.multOpt.handle_subproblems.get_involved_cfs_list(problem_string)

Get a list of integers of the involved cost functions.

Parameters:	problem_string (`str`) – Contains the numbers of the involved cost functions separated by a comma as a string , e.g., “1,2” for the subproblem with the cost functions \(f_1\) and \(f_2\).
Returns:	subproblem_single_list – List of integers corresponding to the numbers of the involved cost functions. For the above example: [1, 2]
Return type:	`list`

oppy.multOpt.handle_subproblems.get_involved_cfs_array(problem_string)

Get an np-array of integers of the involved cost functions.

Parameters:	problem_string (`str`) – Contains the numbers of the involved cost functions separated by a comma as a string , e.g., “1,2” for the subproblem with the cost functions \(f_1\) and \(f_2\).
Returns:	subproblem_single_array – Array of size (num_costfun,), where ‘num_costfun’ is the number of cost functions contained in the string, containing the numbers of the involved cost functions. For the above example: array([1, 2])
Return type:	`numpy.ndarray`, shape (num_costfun,)

oppy.multOpt.handle_subproblems.get_involved_cfs_set(problem_string)

Get a set of integers of the involved cost functions.

Parameters:	problem_string (`str`) – Contains the numbers of the involved cost functions separated by a comma as a string , e.g., “1,2” for the subproblem with the cost functions \(f_1\) and \(f_2\).
Returns:	subproblem_single_set – Set of integers corresponding to the numbers of the involved cost functions. For the above example: {1, 2}
Return type:	`set`

oppy.multOpt.handle_subproblems.get_all_subproblems_string(problem_string)

Get list of strings containing all subproblems w.r.t. a subproblem.

Parameters:	problem_string (`str`) – Contains the numbers of the involved cost functions separated by a comma as a string , e.g., “1,2,4” for the subproblem with the cost functions \(f_1\), \(f_2\) and \(f_4\).
Returns:	all_subproblems_string – List of strings containing all subproblems of the current subproblem. Each entry is a string containing the involved cost functions of the subsubproblem. For the above example: [‘1’, ‘2’, ‘4’, ‘1,2’, ‘1,4’, ‘2,4’]
Return type:	`list`

oppy.multOpt.handle_subproblems.get_all_subproblems_set(problem_string)

Get list of strings containing all subproblems w.r.t. a subproblem.

Parameters:	problem_string (`str`) – Contains the numbers of the involved cost functions separated by a comma as a string , e.g., “1,2,4” for the subproblem with the cost functions \(f_1\), \(f_2\) and \(f_4\).
Returns:	all_subproblems_set – List of sets containing all subproblems of the current subproblem. Each entry is a set containing the involved cost functions of the subsubproblem. For the above example: [{1}, {2}, {4}, {1, 2}, {1, 4}, {2, 4}]
Return type:	`list`

oppy.multOpt.handle_subproblems.get_missing_cfs_set(problem_string, cf_string)

Missing cost functions of a subproblem w.r.t. a subproblem as set.

Parameters:	problem_string (`str`) – Contains the numbers of the involved cost functions separated by a comma as a string , e.g., “1,2,4” for the subproblem with the cost functions \(f_1\), \(f_2\) and \(f_4\). cf_string (`str`) – Contains another subproblem as a string, e.g., “1” for the subproblem with the cost functions \(f_1\).
Returns:	cf_missing_set – Contains a set of integers with the numbers of the missing cost functions. In the above example: {2, 4}
Return type:	`set`

oppy.multOpt.handle_subproblems.get_missing_cfs_string(problem_string, cf_string)

Missing cost functions of a subproblem w.r.t. a subproblem as string.

Parameters:	problem_string (`str`) – Contains the current subproblem as a string, e.g., “1,2,4” for the subproblem with the cost functions \(f_1\), \(f_2\) and \(f_4\). cf_string (`str`) – Contains another subproblem as a string, e.g., “1” for the subproblem with the cost functions \(f_1\).
Returns:	cf_missing_string – String containing the numbers of the missing cost functions separated by a comma. In the above example: “2,4”
Return type:	`str`

oppy.multOpt.psm module

Pascoletti-Serafini method.

oppy.multOpt.psm.psm(fhandle, dfhandle, x, low, up, MOP, data, options, ddfhandle=None)

The Pascoletti-Serafini method.

This method solves a given subproblem (potentially the entire problem) of a given multiobjective optimization problem by the Pascoletti-Serafini method. It uses information from already solved subproblems of the current subproblem to create the refernce points for the current subproblem. For all created reference points z, the Pascoletti-Serafini problem

\[\min_x \max_{i \in \{1,\ldots,k\}} \frac{1}{r_i} (f_i(x) - z_i)\]

\[\text{s.t. } \text{low} \leq x \leq \text{up}\]

is solved. For the numerical optimization, this non-smooth problem is reformulated as

\[\min_{x,t} t\]

\begin{eqnarray} \text{s.t. } f_i(x) - z_i - t r_i & \leq 0, \\ \text{low} \leq x & \leq \text{up}, \end{eqnarray}

which is solved by using an optimization method being able to deal with these kind of problems (preferably the augmented Lagrange method). The optimization method is specified in the options.

Parameters:

fhandle (list of callable(), length k) –
The list of length k containing the objective functions of the entire multiobjective optimization problem. Note that not all of them might be considered, but only those who are part of the current subproblem specified in data. For the i-th entry of the list with \(0 \leq i \leq k-1\) we have

fhandle[i](x, *fargs) -> float

where x is an 1-D array with shape (n,) and args is a tuple of the fixed parameters needed to completely specify the function.
dfhandle (list of callable(), length k) –
The list of length k containing the gradients of the entire multiobjective optimization problem. Note that not all of them might be considered, but only those who are part of the current subproblem specified in data. For the i-th entry with \(0 \leq i \leq k-1\) we have

dfhandle[i](x, *fargs) -> array_like, shape (n,).

where x is an 1-D array with shape (n,) and fargs is a tuple of the fixed parameters needed to completely specify the function.
x (numpy.ndarray, shape (n,)) – Initial guess for solving the scalar optimization problems. Array of real elements of size (n,), where ‘n’ is the number of independent variables.
low (numpy.ndarray, shape (n,)) – Lower bound. Array of real elements of size (n,), where ‘n’ is the number of independent variables.
up (numpy.ndarray, shape (n,)) – Upper bound. Array of real elements of size (n,), where ‘n’ is the number of independent variables.
MOP (dict) –
Dictionary containing the solutions to the multiobjective optimization problem. It conatins keys given by the strings of all already solved subproblems, e.g., it contains the key “1,2”, if the subproblem with the cost functions \(f_1\) and \(f_2\) has already been solved. Each of the values corresponding to such a key is a dictionary itself and contains the following keys:
- ”Results”list of Results, length num_sol
  
  List of instances of the class Results with length num_sol, where num_sol is the number of computed Pareto optimal points of the current subproblem. Represents the optimization results. Attributes of the object depend on the choice of the options.results parameter. With default choice the object has the following attributes:
  
  xnumpy.ndarray, shape (n,)
  
  Solution vector of the optimization problem.
  
  iterationsint
  
  Number of iterations the algorithm needed.
  
  reslist
  
  List with the norm of the residuals.
- ”func_values”numpy.ndarray, shape (num_sol, k)
  
  Pareto optimal function values of the current subproblem. Array of size (num_sol, k), where ‘num_sol’ is the number of computed Pareto optimal points of the current subproblem and ‘k’ is the number of total cost functions of the MOP.
- ”x”numpy.ndarray, shape (num_sol, n)
  
  Pareto optimal points of the current subproblem. Array of size (num_sol, n), where ‘num_sol’ is the number of computed Pareto optimal points of the current subproblem and ‘n’ is the number of independent variables.
- ”t”numpy.ndarray, shape (num_sol,)
  
  Optimal max-values of the computed Pareto-optimal points. Array of size (num_sol,), where ‘num_sol’ is the number of computed Pareto optimal points of the current subproblem.
- ”z_ref”numpy.ndarray, shape (num_z_ref, k_current)
  
  Reference points for the current subproblem. Array of size (num_z_ref, k_current), where ‘num_z_ref’ is the number of referece points and k_current is the number of cost functions of the current subproblem.
- ”z_ref_all”numpy.ndarray, shape (num_z_ref, k)
  
  Reference points for the current subproblem seen as reference points of the entire multiobjective optimization problem. Created by adding the function values of the non-involved cost functions to the reference points from “z_ref” in the respective dimensions. Array of size (num_z_ref, k), where ‘num_z_ref’ is the number of reference points and ‘k’ is the number of cost function of the entire multiobjective optimization problem.
data (dict) –
Dictionary containing additional data of the multiobjective optimization problem. It contains keys given by the strings of all already solved subproblems, e.g., it contains the key “1,2”, if the subproblem with the cost functions \(f_1\) and \(f_2\) has already been solved.
- ”1,2”dict
  
  Dictionary containing the key
  
  ”ynad”numpy.ndarray, shape (k,)
  
  Nadir point of the subproblem “1,2” w.r.t. all cost functions. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
  
  ”z_ref_create”list
  
  Information about the reference points of the current subproblem, which are needed to create reference points for all superproblems of the current subproblem. Each entry of the list is a dictionary and corresponds to a reference points. It has the following (key,value) pairs:
  
  ”Coordinates”numpy.ndarray, shape (k,)
  
  Coordinates of the current reference point w.r.t. all cost functions (see z_ref_all in MOP). Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
  
  ”Boxnumber”numpy.ndarray of int, shape (k,)
  
  Specifies the box on the shifted coordinate plane that the current reference point lies in. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
  
  ”Subproblem”str
  
  The subproblem to which the current reference point belongs, written as a string (e.g, the str “1,2” stands for the subproblem with the cost functions \(f_1\) and \(f_2\)).
  
  ”Missing_CFs”str
  
  The missing cost functions that are not part of the current subproblem written as a string (e.g., the string “3,4” means that the cost functions \(f_3\) and \(f_4\) are not part of the current subproblem).
  
  ”Coordinate_Plane”str
  
  Index of the coordinate plane that the current reference point lies on written as a string.
Additionally, data contains the following keys:
- ”yid”numpy.ndarray, shape (k,)
  
  Ideal point of the multiobjective optimization problem. Array of size (k,), where ‘k’ is the nunmber of cost functions of the entire multiobjective optimization problem. The value of each entry is given by the minimal value of the corresponding cost function.
- ”yidshift”numpy.ndarray, shape (k,)
  
  Shifted ideal point of the multiobjective optimization problem. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem. The shifted ideal point is given by yid - d, where d is the specified shifting vector of the problem.
- ”current_subproblem”tuple, length num_current_sp
  
  Tuple containing the indices of the cost functions involved in the current subproblem. Tuple of length num_current_sp, where ‘num_current_sp’ is the number of cost functions in the current subproblem.
options (Options, optional) –
Options for the weighted-sum method method, represented as a Options object. The default is None. Possible/Relevant options for the Pascoletti-Serafini method are:
- mop_methodstr
  
  Scalarization method, with which the multiobjective optimization problem is supposed to be solved. Possible choices are “WSM”, “ERPM” and “PSM”. This method is only called, if the method is “ERPM”.
- r_PSMnumpy.ndarray, shape (k,)
  
  Target direction r for the Pascoletti-Serafini problem. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
- hpfloat
  
  Shifting value for the coordinate axis containing the reference points.
- hxfloat
  
  Grid size of the reference point grid.
- PSM_optimethcallable()
  
  Callable function that solves the Pascoletti-Serafini problems, initialized with the augmented Lagrangian method.
- problem_typestr
  
  Indicates if the problem is convex or non-convex. The string can either contain “convex” or “non-convex”, initialized with “convex”.
ddfhandle (list of callable(), length k, optional) –
The list of length k containing the Hessians of the objective functions. Only required if the optimizer is a second order method. Therefore, the default is None. Otherwise, note that not all of them might be considered, but only those who are part of the current subproblem specified in data. For the i-th entry of the list with \(0 \leq i \leq k-1\) we have

ddfhandle[i](x, *fargs) -> array_like, shape (n,n).

where x is an 1-D array with shape (n,) and args is a tuple of the fixed parameters needed to completely specify the function.

Returns:

MOP (dict) – Dictionary containing the solutions to the multiobjective optimization problem. In addition to the input, the key corresponding to the current subproblem has been added. The value of this key is a dictionary itself and contains the following keys:
- ”Results”list of Results, length num_sol
  
  List of instances of the class Results with length num_sol, where num_sol is the number of computed Pareto optimal points of the current subproblem. Represents the optimization results. Attributes of the object depend on the choice of the options.results parameter. With default choice the object has the following attributes:
  
  xnumpy.ndarray, shape (n,)
  
  Solution vector of the optimization problem.
  
  iterationsfloat
  
  Number of iterations the algorithm needed.
  
  reslist
  
  List with the norm of the residuals.
- ”func_values”numpy.ndarray, shape (num_sol, k)
  
  Pareto optimal function values of the current subproblem. Array of size (num_sol, k), where ‘num_sol’ is the number of computed Pareto optimal points of the current subproblem and ‘k’ is the number of total cost functions of the MOP.
- ”x”numpy.ndarray, shape (num_sol, n)
  
  Pareto optimal points of the current subproblem. Array of size (num_sol, n), where ‘num_sol’ is the number of computed Pareto optimal points of the current subproblem and ‘n’ is the number of independent variables.
- ”t”numpy.ndarray, shape (num_sol,)
  
  Optimal max-values of the computed Pareto-optimal points. Array of size (num_sol,), where ‘num_sol’ is the number of computed Pareto optimal points of the current subproblem.
- ”z_ref”numpy.ndarray, shape (num_z_ref, k_current)
  
  Reference points for the current subproblem. Array of size (num_z_ref, k_current), where ‘num_z_ref’ is the number of referece points and k_current is the number of cost functions of the current subproblem.
- ”z_ref_all”numpy.ndarray, shape (num_z_ref, k)
  
  Reference points for the current subproblem seen as reference points of the entire multiobjective optimization problem. Created by adding the function values of the non-involved cost functions to the reference points from “z_ref” in the respective dimensions. Array of size (num_z_ref, k), where ‘num_z_ref’ is the number of reference points and ‘k’ is the number of cost function of the entire multiobjective optimization problem.
data (dict) – Dictionary containing additional data of the multiobjective optimization problem. In comparison to the input, the key corresponding to the current subproblem has been added. The value of this key is a dictionary itself and contains the following key:
- ”ynad”numpy.ndarray, shape (k,)
  
  Nadir point of the current subproblem w.r.t. all cost functions. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
- ”z_ref_create”list
  
  Information about the reference points of the current subproblem, which are needed to create reference points for all superproblems of the current subproblem. Each entry of the list is a dictionary and corresponds to a reference points. It has the following (key,value) pairs:
  
  ”Coordinates”numpy.ndarray, shape (k,)
  
  Coordinates of the current reference point w.r.t. all cost functions (see z_ref_all in MOP). Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
  
  ”Boxnumber”numpy.ndarray of int, shape (k,)
  
  Specifies the box on the shifted coordinate plane that the current reference point lies in. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
  
  ”Subproblem”str
  
  The subproblem to which the current reference point belongs, written as a string (e.g, the string “1,2” stands for the subproblem with the cost functions \(f_1\) and \(f_2\)).
  
  ”Missing_CFs”str
  
  The missing cost functions that are not part of the current subproblem written as a string (e.g., the string “3,4” means that the cost functions \(f_3\) and \(f_4\) are not part of the current subproblem).
  
  ”Coordinate_Plane”str
  
  Index of the coordinate plane that the current reference point lies on written as a string.

References

S. Banholzer. ROM-Based Multiobjective Optimization with PDE Constraints. PhD Thesis, University of Konstanz, 2021, see Banholzer [Ban21].

G. Eichfelder. Adaptive Scalarization Methods in Multiobjective Optimization. Springer, Berlin, Heidelberg, First Edition, 2008, see Eichfelder [Eic08].

K. Khaledian and M. Soleimani-damaneh. A New Approach to Approximate the Bounded Pareto Front. Mathematical Methods of Operations Research, 82(2):211–228, 2015, see Khaledian and Soleimani-damaneh [KSd15].

D. Mueller-Gritschneder, H. Graeb and U. Schlichtmann. A Successive Approach to Compute the Bounded Pareto Front of Practical Multiobjective Optimization Problems. SIAM J. Optim., 20(2):915–934, 2009, see Mueller-Gritschneder et al. [MGGS09].

A. Pascoletti and P. Serafini. Scalarizing Vector Optimization Problems. Journal of Optimization Theory and Applications, 42(4):499–524, 1984, see Pascoletti and Serafini [PS84].

oppy.multOpt.psm.create_reference_points(data, options)

Create the reference points for the Pascoletti-Serafini method.

This method creates the reference points for the Pascoletti-Serafini method by using information of the solutions of all subproblems of the current problem.

Parameters:	data (`dict`) – Dictionary containing additional data of the multiobjective optimization problem. It contains keys given by the strings of all already solved subproblems, e.g., it contains the key “1,2”, if the subproblem with the cost functions \(f_1\) and \(f_2\) has already been solved. ”1,2”`dict` Dictionary containing the keys ”ynad”`numpy.ndarray`, shape (k,) Nadir point of the subproblem “1,2” w.r.t. all cost functions. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem. ”z_ref_create”`list` Information about the reference points of the current subproblem, which are needed to create reference points for all superproblems of the current subproblem. Each entry of the list is a dictionary and corresponds to a reference points. It has the following (key,value) pairs: ”Coordinates”`numpy.ndarray`, shape (k,) Coordinates of the current reference point w.r.t. all cost functions (see z_ref_all in MOP). Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem. ”Boxnumber”`numpy.ndarray` of `int`, shape (k,) Specifies the box on the shifted coordinate plane that the current reference point lies in. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem. ”Subproblem”`str` The subproblem to which the current reference point belongs, written as a string (e.g, the string “1,2” stands for the subproblem with the cost functions \(f_1\) and \(f_2\)). ”Missing_CFs”`str` The missing cost functions that are not part of the current subproblem written as a string (e.g., the string “3,4” means that the cost functions \(f_3\) and \(f_4\) are not part of the current subproblem). ”Coordinate_Plane”`str` Index of the coordinate plane that the current reference point lies on written as a string. Additionally, data contains the following keys: ”yid”`numpy.ndarray`, shape (k,) Ideal point of the multiobjective optimization problem. Array of size (k,), where ‘k’ is the nunmber of cost functions of the entire multiobjective optimization problem. The value of each entry is given by the minimal value of the corresponding cost function. ”yidshift”`numpy.ndarray`, shape (k,) Shifted ideal point of the multiobjective optimization problem. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem. The shifted ideal point is given by yid - d, where d is the specified shifting vector of the problem. ”current_subproblem”`tuple`, length num_current_sp Tuple containing the indices of the cost functions involved in the current subproblem. Tuple of length num_current_sp, where ‘num_current_sp’ is the number of cost functions in the current subproblem. options (`Options`, optional) – Options for the Pascoletti-Serafini method, represented as a `Options` object. The default is None. Possible/Relevant options for the creation of the reference points are: hp`float` Shifting value for the coordinate axis containing the reference points. hx`float` Grid size of the reference point grid.
Returns:	z_ref – Created reference point for the current subproblem. Array of size (num_z_ref, num_current_sp), where ‘num_z_ref’ is the number of reference points and num_current_sp is the number of cost functions of the current subproblem.
Return type:	`numpy.ndarray`, shape (num_z_ref, num_current_sp)

oppy.multOpt.psm.create_z_ref_grid(interval_list)

Create the reference point grid for the current subproblem.

This method creates the reference point grid on the shifted coordinate planes.

Parameters:	interval_list (`list`, length num_current_sp) – List of reference point grids of the individual cost functions that are part of the current subproblem. The length of the list is num_current_sp, which is the number of the cost functions of the current subproblem. Each entry of the list is an array containing the reference point grid for the respective cost function.
Returns:	z_ref_grid – Reference point grid on the shifted coordinate planes. Array of size (num_z_ref_grid, num_current_sp), where ‘num_z_ref_grid’ is the number of reference points on the grid and ‘num_current_sp’ is the number of cost functions of the current subproblem.
Return type:	`numpy.ndarray`, shape (num_z_ref_grid, num_current_sp)

oppy.multOpt.psm.evalFunc_InequConstr_PSM(fhandle, xt, z, r_target)

Evaluate the inequality constraints of the Pascoletti-Serafini problem.

This method evaluates the inequality constraints of the Pascoletti-Serafini problem at the current point xt = \((x,t)\).

Parameters:	fhandle (`list` of `callable()`, length num_costfun) – The list containing the objective functions of the considered Pascoletti-Serafini problem. For the i-th entry of the list with \(0 \leq i \leq \text{num_costfun} - 1\), we have `fhandle[i](x, fargs) -> float` where x is an 1-D array with shape (n,) and args is a tuple of the fixed parameters needed to completely specify the function. xt (`numpy.ndarray`, shape (n+1,)) – Contains \((x,t)\). Array of real elements of size (n+1,), where ‘n’ is the number of independent variables. z (`numpy.ndarray`, shape (num_costfun,)) – Reference point of the Euclidean reference point function. Array of size (num_costfun,), where ‘num_costfun’ is the number of cost functions. r_target* (`numpy.ndarray`, shape (num_costfun,)) – Target direction of the Pascoletti-Serafini problem. Array of size (num_costfun,), where ‘num_costfun’ is the number of cost functions.
Returns:	func_val – Function value of the inequality constraints of the Pascoletti-Serafini problem at the current point xt. Array of size (num_costfun,), where ‘num_costfun’ is the number of cost functions.
Return type:	`numpy.ndarray`, shape (num_costfun,)

oppy.multOpt.psm.evalGrad_InequConstr_PSM(dfhandle, xt, z, r_target)

Evaluate gradient of the ineq. constr. of the Pascoletti-Serafini.

This method evaluates the gradients of the inequality constraints of the Pascoletti-Serafini problem at the current point xt = (x,t).

Parameters:	dfhandle (`list` of `callable()`, length num_costfun) – The list containing the gradients of the objective functions of the considered Pascoletti-Serafini problem. For the i-th entry of the list with \(0 \leq i \leq \text{num_costfun} - 1\), we have `dfhandle[i](x, fargs) -> array_like, shape (n,).` where x is an 1-D array with shape (n,) and fargs is a tuple of the fixed parameters needed to completely specify the function. xt (`numpy.ndarray`, shape (n+1,)) – Contains \((x,t)\). Array of real elements of size (n+1,), where ‘n’ is the number of independent variables. z (`numpy.ndarray`, shape (num_costfun,)) – Reference point of the Euclidean reference point function. Array of size (num_costfun,), where ‘num_costfun’ is the number of cost functions. r_target* (`numpy.ndarray`, shape (num_costfun,)) – Target direction of the Pascoletti-Serafini problem. Array of size (num_costfun,), where ‘num_costfun’ is the number of cost functions.
Returns:	grad_val – Gradient of the inequality constraints of the Pascoletti-Serafini problem. Array of size (num_costfun, n+1), where num_costfun is the number of cost functions, and ‘n’ is the number of independent variables. The rows of the array contain the gradients of the inequality constraints.
Return type:	`numpy.ndarray`, shape (num_costfun, n+1)

oppy.multOpt.psm.evalHess_InequConstr_PSM(ddfhandle, xt, z, r_target)

Evaluate gradient of the ineq. constr. of the Pascoletti-Serafini.

This method evaluates the gradients of the inequality constraints of the Pascoletti-Serafini problem at the current point xt = (x,t).

Parameters:	ddfhandle (`list` of `callable()`, length num_costfun) – The list containing the Hessians of the objective functions of the considered Pascoletti-Serafini problem. For the i-th entry of the list with \(0 \leq i \leq \text{num_costfun} - 1\), we have `ddfhandle[i](x, fargs) -> array, shape (n, n).` where x is an 1-D array with shape (n,) and fargs is a tuple of the fixed parameters needed to completely specify the function. xt (`numpy.ndarray`, shape (n+1,)) – Contains \((x,t)\). Array of real elements of size (n+1,), where ‘n’ is the number of independent variables. z (`numpy.ndarray`, shape (num_costfun,)) – Reference point of the Euclidean reference point function. Array of size (num_costfun,), where ‘num_costfun’ is the number of cost functions. r_target* (`numpy.ndarray`, shape (num_costfun,)) – Target direction of the Pascoletti-Serafini problem. Array of size (num_costfun,), where ‘num_costfun’ is the number of cost functions.
Returns:	hess_val – Hessian of the inequality constraints of the Pascoletti-Serafini problem. Array of size (num_costfun, n+1, n+1), where num_costfun is the number of cost functions, and ‘n’ is the number of independent variables. The second and third dimension of the array contain the Hessian of the respective inequality constraint.
Return type:	`numpy.ndarray`, shape (num_costfun, n+1, n+1)

oppy.multOpt.wsm module

Weighted-sum method.

This method is well-suited for quickly solving convex problems.

However, note that the approximation of the Pareto front might be non-uniform, since there might be regions, which are badly approximated and other regions, where the approximation points cluster (see Das and Dennis [DD97] in the references).

oppy.multOpt.wsm.wsm(fhandle, dfhandle, x, low, up, MOP, data, options=None, ddfhandle=None)

The weighted-sum method.

This method solves a given subproblem (potentially the entire problem) of a given multiobjective optimization problem by the weighted-sum method. If ‘k’ is the number of cost functions of the current problem, then the set of convex combinations

\[\Delta_k = \{\alpha \in \mathbb{R}^k_\geq \mid \sum_{i=1}^k \alpha_i = 1\}\]

is discretized by using a number of discretization points per dimensio, which is specified in the options. For all weights alpha in this discretized set of weights, the weighted-sum problem

\[\min_x \sum_{i=1}^k \alpha_i f_i(x)\]

\[\text{low} \leq x \leq \text{up}\]

is solved by using an optimziation method for constrained optimization, which is specified in the options.

Parameters:

fhandle (list of callable(), length k) –
The list of length k containing the objective functions of the entire multiobjective optimization problem. Note that not all of them might be considered, but only those who are part of the current subproblem specified in data. For the i-th entry of the list with \(0 \leq i \leq k-1\) we have

fhandle[i](x, *fargs) -> float

where x is an 1-D array with shape (n,) and args is a tuple of the fixed parameters needed to completely specify the function.
dfhandle (list of callable(), length k) –
The list of length k containing the gradients of the entire multiobjective optimization problem. Note that not all of them might be considered, but only those who are part of the current subproblem specified in data. For the i-th entry with \(0 \leq i \leq k-1\) we have

dfhandle[i](x, *fargs) -> array_like, shape (n,).

where x is an 1-D array with shape (n,) and fargs is a tuple of the fixed parameters needed to completely specify the function.
ddfhandle (list of callable(), length k, optional) –
The list of length k containing the Hessians of the entire multiobjective optimization problem. Note that not all of them might be considered, but only those who are part of the current subproblem specified in data. For the i-th entry of the list with \(0 \leq i \leq k-1\) we have

ddfhandle[i](x, *fargs) -> array_like, shape (n,n).

where x is an 1-D array with shape (n,) and args is a tuple of the fixed parameters needed to completely specify the function.
x (numpy.ndarray, shape (n,)) – Initial guess for solving the first weighted-sum problem in case of a scalar problem (k = 1 cost function). Array of real elements of size (n,), where ‘n’ is the number of independent variables.
low (numpy.ndarray, shape (n,)) – Lower bound. Array of real elements of size (n,), where ‘n’ is the number of independent variables.
up (numpy.ndarray, shape (n,)) – Upper bound. Array of real elements of size (n,), where ‘n’ is the number of independent variables.
MOP (dict) –
Dictionary containing the solutions to the multiobjective optimization problem. It conatins keys given by the strings of all already solved subproblems, e.g., it contains the key “1,2”, if the subproblem with the cost functions \(f_1\) and \(f_2\) has already been solved. Each of the values corresponding to such a key is a dictionary itself and contains the following keys:
- ”Results”list of Results, length num_sol
  
  List of instances of the class Results with length num_sol, where num_sol is the number of Pareto optimal points of the current subproblem. Represents the optimization results. Attributes of the object depend on the choice of the options.results parameter. With default choice the object has the following attributes:
  
  xnumpy.ndarray, shape (n,)
  
  Solution vector of the optimization problem.
  
  iterationsint
  
  Number of iterations the algorithm needed.
  
  reslist
  
  List with the norm of the residuals.
- ”func_values”numpy.ndarray, shape (num_sol, k)
  
  Pareto optimal function values of the current subproblem. Array of size (num_sol, k), where ‘num_sol’ is the number of Pareto optimal points of the current subproblem and ‘k’ is the number of total cost functions of the multiobjective optimization problem.
- ”x”numpy.ndarray, shape (num_sol, n)
  
  Pareto optimal points of the current subproblem. Array of size (num_sol, n), where ‘num_sol’ is the number of Pareto optimal points of the current subproblem and ‘n’ is the number of independent variables.
- ”alpha”numpy.ndarray, shape (num_alpha, k_current)
  
  Weight vectors for the current subproblem. Array of size (num_alpha, k_current), where ‘num_alpha’ is the number of weight vectors and k_current is the number of cost functions of the current subproblem.
- ”alpha_all”numpy.ndarray, shape (num_alpha, k)
  
  Weight vectors for the current subproblem seen as weights of the entire MOP. Created by adding 0s to the weights from “alpha” in the respective dimensions. Array of size (num_alpha, k), where ‘num_alpha’ is the number of weight vectors and ‘k’ is the number of cost function of the entire multiobjective optimization problem.
data (dict) –
Dictionary containing additional data of the multiobjective optimization problem. It contains keys given by the strings of all already solved subproblems, e.g., it contains the key “1,2”, if the subproblem with the cost functions \(f_1\) and \(f_2\) has already been solved.
- ”1,2”dict
  
  Dictionary containing the key
  
  ”ynad”numpy.ndarray, shape (k,)
  
  Nadir point of the subproblem “1,2” w.r.t. all cost functions. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.
Additionally, data contains the following keys:
- ”yid”numpy.ndarray, shape (k,)
  
  Ideal point of the multiobjective optimization problem. Array of size (k,), where ‘k’ is the nunmber of cost functions of the entire multiobjective optimization problem. The value of each entry is given by the minimal value of the corresponding cost function.
- ”yidshift”numpy.ndarray, shape (k,)
  
  Shifted ideal point of the multiobjective optimization problem. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem. The shifted ideal point is given by yid - d, where d is the specified shifting vector of the problem.
- ”current_subproblem”tuple, length num_current_sp
  
  Tuple containing the indices of the cost functions involved in the current subproblem. Tuple of length num_current_sp, where ‘num_current_sp’ is the number of cost functions in the current subproblem.
options (Options, optional) –
Options for the weighted-sum method method, represented as a Options object. The default is None. Possible/Relevant options for the weighted-sum method are:
- mop_methodstr
  
  Scalarization method, with which the multiobjective optimization problem is supposed to be solved. Possible choices are “WSM”, “ERPM” and “PSM”. Note that the current ‘wsm’-method is also called in case of the scalarization methods “ERPM” and “PSM”, in order to compute the minimizers of the individual cost functions in the first step.
- num_weights_per_dimensionint
  
  Number of weights per dimension used for the discretization of the set of weights
- WSM_optimethcallable()
  
  Callable function that solves the weighted-sum problems, initialized with gradmethod.
- problem_typestr
  
  Indicates if the problem is convex or non-convex. The string can either contain “convex” or “non-convex”, initialized with “convex”.
ddfhandle –
The list of length k containing the Hessians of the objective functions. Only required if the optimizer is a second order method. Therefore, the default is None. Otherwise, note that not all of them might be considered, but only those who are part of the current subproblem specified in data. For the i-th entry of the list with \(0 \leq i \leq k-1\) we have

ddfhandle[i](x, *fargs) -> array_like, shape (n,n).

where x is an 1-D array with shape (n,) and args is a tuple of the fixed parameters needed to completely specify the function.

Returns:

MOP (dict) – Dictionary containing the solutions to the multiobjective optimization problem. In addition to the input, the key corresponding to the current subproblem has been added. The value of this key is a dictionary itself and contains the following keys:
- ”Results”list, length num_sol
  
  List of instances of the class oppy.results.results.Results with length num_sol, where num_sol is the number of Pareto optimal points of the current subproblem. Represents the optimization results. Attributes of the object depend on the choice of the options.results parameter. With default choice the object has the following attributes:
  
  xnumpy.ndarray, shape (n,)
  
  Solution vector of the optimization problem.
  
  iterationsscalar
  
  Number of iterations the algorithm needed.
  
  reslist
  
  List with the norm of the residuals.
- ”func_values”numpy.ndarray, shape (num_sol, k)
  
  Pareto optimal function values of the current subproblem. Array of size (num_sol, k), where ‘num_sol’ is the number of Pareto optimal points of the current subproblem and ‘k’ is the number of total cost functions of the MOP.
- ”x”numpy.ndarray, shape (num_sol, n)
  
  Pareto optimal points of the current subproblem. Array of size (num_sol, n), where ‘num_sol’ is the number of Pareto optimal points of the current subproblem and ‘n’ is the number of independent variables.
- ”alpha”numpy.ndarray, shape (num_alpha, k_current)
  
  Weight vectors for the current subproblem. Array of size (num_alpha, k_current), where ‘num_alpha’ is the number of weight vectors and k_current is the number of cost functions of the current subproblem.
- ”alpha_all”numpy.ndarray, shape (num_alpha, k)
  
  Weight vectors for the current subproblem seen as weights of the entire MOP. Created by adding 0s to the weights from “alpha” in the respective dimensions. Array of size (num_alpha, k), where ‘num_alpha’ is the number of weight vectors and k is the number of cost function of the entire MOP.
data (dict) – Dictionary containing additional data of the multiobjective optimization problem. In comparison to the input, the key corresponding to the current subproblem has been added. The value of this key is a dictionary itself and contains the following key:
- ”ynad”numpy.ndarray, shape (k,)
  
  Nadir point of the current subproblem w.r.t. all cost functions. Array of size (k,), where ‘k’ is the number of cost functions of the entire multiobjective optimization problem.

References

I. Das and J.E. Dennis. A closer Look at Drawbacks of Minimizing Weighted Sums of Objectives for Pareto Set Generation in Multcriteria Optimization Problems. Structural optimization, 14:63-69, 1997, see Das and Dennis [DD97]. M. Ehrgott. Multicriteria Optimization. Springer, Berlin, Heidelberg, Second Edition, 2005, see Ehrgott [Ehr05].

K.M. Miettinen. Nonlinear Multiobjective Optimization. Kluwer Academic Publishers, AH Dordrecht, First Edition, 1999, see Miettinen [Mie99].

L. Zadeh. Optimality and Non-Scalar-Valued Performance Criteria. IEEE Transactions on Automatic Control, 8(1):59–60, 1963, see Zadeh [Zad63].

oppy.multOpt.wsm.create_weights(dim, num_weights_per_dimension, val=1)

Create the weights for the weighted-sum method.

This method creates the discretized weights for the weighted-sum method. It recursively calls itself to build the weights.

Parameters:	dim (`int`) – Dimension of the weight space. num_weights_per_dimension (`int`) – Number of discretization points per dimension. val (`float`, optional) – Value that the weights have to sum up to. The default is 1.
Returns:	alpha – Discretized weight vectors. Array of size (num_alpha, dim), where ‘num_alpha’ is the number of weight vectors and ‘dim’ is the dimension of the weight space.
Return type:	`numpy.ndarray`, shape (num_alpha, dim)

oppy.multOpt.wsm.evalFunc_WSM(fhandle, x, alpha)

Evaluate the weighted-sum function.

This method evaluates the weighted-sum function given the point x and the weight alpha.

Parameters:	fhandle (`list` of `callable()`, length num_costfun) – The list containing the objective functions of the considered weighted-sum function. For the i-th entry of the list with \(0 \leq i \leq \text{num_costfun} - 1\), we have `fhandle[i](x, fargs) -> float` where x is an 1-D array with shape (n,) and args is a tuple of the fixed parameters needed to completely specify the function. x (`numpy.ndarray`, shape (n,)) – Current value of the variable. Array of real elements of size (n,), where ‘n’ is the number of independent variables. alpha* (`numpy.ndarray`, shape (num_costfun,)) – Weight vector of the weighted-sum function. Array of size (num_costfun,), where ‘num_costfun’ is the number of cost functions.
Returns:	func_val – Function value of the weighted-sum function.
Return type:	`float`

oppy.multOpt.wsm.evalGrad_WSM(dfhandle, x, alpha)

Evaluate the gradient of the weighted-sum function.

This method evaluates the gradient of the weighted-sum function given the point x and the weight alpha.

Parameters:	dfhandle (`list` of `callable()`, length num_costfun) – The list containing the gradients of the objective functions of the considered weighted-sum function. For the i-th entry of the list with \(0 \leq i \leq \text{num_costfun} - 1\), we have `dfhandle[i](x, fargs) -> array_like, shape (n,).` where x is an 1-D array with shape (n,) and fargs is a tuple of the fixed parameters needed to completely specify the function. x (`numpy.ndarray`, shape (n,)) – Current value of the variable. Array of real elements of size (n,), where ‘n’ is the number of independent variables. alpha* (`numpy.ndarray`, shape (num_costfun,)) – Weight vector of the weighted-sum function. Array of size (num_costfun,), where ‘num_costfun’ is the number of cost functions.
Returns:	grad_val – Gradient of the weighted-sum function at the point x. Array of size (n,), where ‘n’ is the number of independent variables.
Return type:	`numpy.ndarray`, shape (n,)

oppy.multOpt.wsm.evalHess_WSM(ddfhandle, x, alpha)

Evaluate the Hessian of the weighted-sum function.

This method evaluates the Hessian of the weighted-sum function given the point x and the weight alpha.

Parameters:	ddfhandle (`list` of `callable()`, length num_costfun) – The list containing the Hessians of the objective functions of the considered weighted-sum function. For the i-th entry of the list with \(0 \leq i \leq \text{num_costfun} - 1\), we have `ddfhandle[i](x, fargs) -> array_like, shape (n,n).` where x is an 1-D array with shape (n,) and args is a tuple of the fixed parameters needed to completely specify the function. x (`numpy.ndarray`, shape (n,)) – Current value of the variable. Array of real elements of size (n,), where ‘n’ is the number of independent variables. alpha* (`numpy.ndarray`, shape (num_costfun,)) – Weight vector of the weighted-sum function. Array of size (num_costfun,), where ‘num_costfun’ is the number of cost functions.
Returns:	hess_val – Hessian of the weighted-sum function at the point x. Array of size (n,n), where ‘n’ is the number of independent variables.
Return type:	`numpy.ndarray`, shape (n,n)