(self, N, maxevals=10, aggregate=np.median, reevals=None, epsilon=1e-7, parallel=False)
parameters are
            `N`
                dimension
            `maxevals`
                maximal value for ``self.evaluations``, where
                ``self.evaluations`` function calls are aggregated for
                noise treatment. With ``maxevals == 0`` the noise
                handler is (temporarily) "switched off". If `maxevals`
                is a list, min value and (for >2 elements) median are
                used to define minimal and initial value of
                ``self.evaluations``. Choosing ``maxevals > 1`` is only
                reasonable, if also the original ``fit`` values (that
                are passed to `__call__`) are computed by aggregation of
                ``self.evaluations`` values (otherwise the values are
                not comparable), as it is done within `fmin()`.
            `aggregate`
                function to aggregate single f-values to a 'fitness', e.g.
                ``np.median``.
            `reevals`
                number of solutions to be reevaluated for noise measurement,
                can be a float, by default set to ``1.5 + popsize/20``,
                zero switches noise handling off.
            `epsilon`
                multiplier for perturbation of the reevaluated solutions
            `parallel`
                a single f-call with all resampled solutions

            :See: `fmin()`, `Options`, `CMAEvolutionStrategy.ask_and_eval()`
parameters are
            `N`
                dimension
            `maxevals`
                maximal value for ``self.evaluations``, where
                ``self.evaluations`` function calls are aggregated for
                noise treatment. With ``maxevals == 0`` the noise
                handler is (temporarily) "switched off". If `maxevals`
                is a list, min value and (for >2 elements) median are
                used to define minimal and initial value of
                ``self.evaluations``. Choosing ``maxevals > 1`` is only
                reasonable, if also the original ``fit`` values (that
                are passed to `__call__`) are computed by aggregation of
                ``self.evaluations`` values (otherwise the values are
                not comparable), as it is done within `fmin()`.
            `aggregate`
                function to aggregate single f-values to a 'fitness', e.g.
                ``np.median``.
            `reevals`
                number of solutions to be reevaluated for noise measurement,
                can be a float, by default set to ``1.5 + popsize/20``,
                zero switches noise handling off.
            `epsilon`
                multiplier for perturbation of the reevaluated solutions
            `parallel`
                a single f-call with all resampled solutions
parameters are N dimension maxevals maximal value for self . evaluations where self . evaluations function calls are aggregated for noise treatment . With maxevals == 0 the noise handler is ( temporarily ) switched off . If maxevals is a list min value and ( for > 2 elements ) median are used to define minimal and initial value of self . evaluations . Choosing maxevals > 1 is only reasonable if also the original fit values ( that are passed to __call__ ) are computed by aggregation of self . evaluations values ( otherwise the values are not comparable ) as it is done within fmin () . aggregate function to aggregate single f - values to a fitness e . g . np . median . reevals number of solutions to be reevaluated for noise measurement can be a float by default set to 1 . 5 + popsize / 20 zero switches noise handling off . epsilon multiplier for perturbation of the reevaluated solutions parallel a single f - call with all resampled solutions
def __init__(self, N, maxevals=10, aggregate=np.median, reevals=None, epsilon=1e-7, parallel=False):
        """parameters are
            `N`
                dimension
            `maxevals`
                maximal value for ``self.evaluations``, where
                ``self.evaluations`` function calls are aggregated for
                noise treatment. With ``maxevals == 0`` the noise
                handler is (temporarily) "switched off". If `maxevals`
                is a list, min value and (for >2 elements) median are
                used to define minimal and initial value of
                ``self.evaluations``. Choosing ``maxevals > 1`` is only
                reasonable, if also the original ``fit`` values (that
                are passed to `__call__`) are computed by aggregation of
                ``self.evaluations`` values (otherwise the values are
                not comparable), as it is done within `fmin()`.
            `aggregate`
                function to aggregate single f-values to a 'fitness', e.g.
                ``np.median``.
            `reevals`
                number of solutions to be reevaluated for noise measurement,
                can be a float, by default set to ``1.5 + popsize/20``,
                zero switches noise handling off.
            `epsilon`
                multiplier for perturbation of the reevaluated solutions
            `parallel`
                a single f-call with all resampled solutions

            :See: `fmin()`, `Options`, `CMAEvolutionStrategy.ask_and_eval()`

        """
        self.lam_reeval = reevals  # 2 + popsize/20, see method indices(), originally 2 + popsize/10
        self.epsilon = epsilon
        self.parallel = parallel
        self.theta = 0.5  # originally 0.2
        self.cum = 0.3  # originally 1, 0.3 allows one disagreement of current point with resulting noiseS
        self.alphasigma = 1 + 2 / (N+10)
        self.alphaevals = 1 + 2 / (N+10)  # originally 1.5
        self.alphaevalsdown = self.alphaevals**-0.25  # originally 1/1.5
        self.evaluations = 1  # to aggregate for a single f-evaluation
        self.minevals = 1
        self.maxevals = int(np.max(maxevals))
        if hasattr(maxevals, '__contains__'):  # i.e. can deal with ``in``
            if len(maxevals) > 1:
                self.minevals = min(maxevals)
                self.evaluations = self.minevals
            if len(maxevals) > 2:
                self.evaluations = np.median(maxevals)
        self.f_aggregate = aggregate
        self.evaluations_just_done = 0  # actually conducted evals, only for documentation
        self.noiseS = 0
def __init__ ( self , N , maxevals = 10 , aggregate = np . median , reevals = None , epsilon = 1e-7 , parallel = False ) : self . lam_reeval = reevals # 2 + popsize/20, see method indices(), originally 2 + popsize/10 self . epsilon = epsilon self . parallel = parallel self . theta = 0.5 # originally 0.2 self . cum = 0.3 # originally 1, 0.3 allows one disagreement of current point with resulting noiseS self . alphasigma = 1 + 2 / ( N + 10 ) self . alphaevals = 1 + 2 / ( N + 10 ) # originally 1.5 self . alphaevalsdown = self . alphaevals ** - 0.25 # originally 1/1.5 self . evaluations = 1 # to aggregate for a single f-evaluation self . minevals = 1 self . maxevals = int ( np . max ( maxevals ) ) if hasattr ( maxevals , '__contains__' ) : # i.e. can deal with ``in`` if len ( maxevals ) > 1 : self . minevals = min ( maxevals ) self . evaluations = self . minevals if len ( maxevals ) > 2 : self . evaluations = np . median ( maxevals ) self . f_aggregate = aggregate self . evaluations_just_done = 0 # actually conducted evals, only for documentation self . noiseS = 0