:py:mod:`desdeo_emo.EAs.NSGAIII`
================================

.. py:module:: desdeo_emo.EAs.NSGAIII


Module Contents
---------------

Classes
~~~~~~~

.. autoapisummary::

   desdeo_emo.EAs.NSGAIII.NSGAIII




.. py:class:: NSGAIII(problem: desdeo_problem.MOProblem, population_size: int = None, population_params: Dict = None, n_survive: int = None, initial_population: desdeo_emo.population.Population.Population = None, lattice_resolution: int = None, selection_type: str = None, interact: bool = False, use_surrogates: bool = False, n_iterations: int = 10, n_gen_per_iter: int = 100, total_function_evaluations: int = 0, keep_archive: bool = False, save_non_dominated: bool = False)

   Bases: :py:obj:`desdeo_emo.EAs.BaseEA.BaseDecompositionEA`

   Python Implementation of NSGA-III. Based on the pymoo package.

   Most of the relevant code is contained in the super class. This class just assigns
   the NSGAIII selection operator to BaseDecompositionEA.

   :param problem: The problem class object specifying the details of the problem.
   :type problem: MOProblem
   :param population_size: The desired population size, by default None, which sets up a default value
                           of population size depending upon the dimensionaly of the problem.
   :type population_size: int, optional
   :param population_params: The parameters for the population class, by default None. See
                             desdeo_emo.population.Population for more details.
   :type population_params: Dict, optional
   :param initial_population: An initial population class, by default None. Use this if you want to set up
                              a specific starting population, such as when the output of one EA is to be
                              used as the input of another.
   :type initial_population: Population, optional
   :param lattice_resolution: The number of divisions along individual axes in the objective space to be
                              used while creating the reference vector lattice by the simplex lattice
                              design. By default None
   :type lattice_resolution: int, optional
   :param selection_type: One of ["mean", "optimistic", "robust"]. To be used in data-driven optimization.
                          To be used only with surrogate models which return an "uncertainity" factor.
                          Using "mean" is equivalent to using the mean predicted values from the surrogate
                          models and is the default case.
                          Using "optimistic" results in using (mean - uncertainity) values from the
                          the surrogate models as the predicted value (in case of minimization). It is
                          (mean + uncertainity for maximization).
                          Using "robust" is the opposite of using "optimistic".
   :type selection_type: str, optional
   :param a_priori: A bool variable defining whether a priori preference is to be used or not.
                    By default False
   :type a_priori: bool, optional
   :param interact: A bool variable defining whether interactive preference is to be used or
                    not. By default False
   :type interact: bool, optional
   :param n_iterations: The total number of iterations to be run, by default 10. This is not a hard
                        limit and is only used for an internal counter.
   :type n_iterations: int, optional
   :param n_gen_per_iter: The total number of generations in an iteration to be run, by default 100.
                          This is not a hard limit and is only used for an internal counter.
   :type n_gen_per_iter: int, optional
   :param total_function_evaluations: Set an upper limit to the total number of function evaluations. When set to
                                      zero, this argument is ignored and other termination criteria are used.
   :type total_function_evaluations: int, optional