pymoo 0.6.1.5.dev0__cp311-cp311-musllinux_1_2_x86_64.whl

pymoo/vendor/hv.py

@@ -0,0 +1,267 @@
+#    Copyright (C) 2010 Simon Wessing
+#    TU Dortmund University
+#    The author (Simon Wessing) has explicitly given the permission for this source code
+#    to be included in pymoo. Thank you!
+
+__author__ = "Simon Wessing"
+
+
+class HyperVolume:
+    """
+    Hypervolume computation based on cross 3 of the algorithm in the paper:
+    C. M. Fonseca, L. Paquete, and M. Lopez-Ibanez. An improved dimension-sweep
+    algorithm for the hypervolume indicator. In IEEE Congress on Evolutionary
+    Computation, pages 1157-1163, Vancouver, Canada, July 2006.
+
+    Minimization is implicitly assumed here!
+
+    """
+
+    def __init__(self, referencePoint):
+        """Constructor."""
+        self.referencePoint = referencePoint
+        self.list = []
+
+    def compute(self, front):
+        """Returns the hypervolume that is dominated by a non-dominated front.
+
+        Before the HV computation, front and reference point are translated, so
+        that the reference point is [0, ..., 0].
+
+        """
+
+        def weaklyDominates(point, other):
+            for i in range(len(point)):
+                if point[i] > other[i]:
+                    return False
+            return True
+
+        relevantPoints = []
+        referencePoint = self.referencePoint
+        dimensions = len(referencePoint)
+        for point in front:
+            # only consider points that dominate the reference point
+            if weaklyDominates(point, referencePoint):
+                relevantPoints.append(point)
+        if any(referencePoint):
+            # shift points so that referencePoint == [0, ..., 0]
+            # this way the reference point doesn't have to be explicitly used
+            # in the HV computation
+            for j in range(len(relevantPoints)):
+                relevantPoints[j] = [relevantPoints[j][i] - referencePoint[i] for i in range(dimensions)]
+        self.preProcess(relevantPoints)
+        bounds = [-1.0e308] * dimensions
+        hyperVolume = self.hvRecursive(dimensions - 1, len(relevantPoints), bounds)
+        return hyperVolume
+
+    def hvRecursive(self, dimIndex, length, bounds):
+        """Recursive call to hypervolume calculation.
+
+        In contrast to the paper, the code assumes that the reference point
+        is [0, ..., 0]. This allows the avoidance of a few operations.
+
+        """
+        hvol = 0.0
+        sentinel = self.list.sentinel
+        if length == 0:
+            return hvol
+        elif dimIndex == 0:
+            # special case: only one dimension
+            # why using hypervolume at all?
+            return -sentinel.next[0].cargo[0]
+        elif dimIndex == 1:
+            # special case: two dimensions, end recursion
+            q = sentinel.next[1]
+            h = q.cargo[0]
+            p = q.next[1]
+            while p is not sentinel:
+                pCargo = p.cargo
+                hvol += h * (q.cargo[1] - pCargo[1])
+                if pCargo[0] < h:
+                    h = pCargo[0]
+                q = p
+                p = q.next[1]
+            hvol += h * q.cargo[1]
+            return hvol
+        else:
+            remove = self.list.remove
+            reinsert = self.list.reinsert
+            hvRecursive = self.hvRecursive
+            p = sentinel
+            q = p.prev[dimIndex]
+            while q.cargo is not None:
+                if q.ignore < dimIndex:
+                    q.ignore = 0
+                q = q.prev[dimIndex]
+            q = p.prev[dimIndex]
+            while length > 1 and (
+                    q.cargo[dimIndex] > bounds[dimIndex] or q.prev[dimIndex].cargo[dimIndex] >= bounds[dimIndex]):
+                p = q
+                remove(p, dimIndex, bounds)
+                q = p.prev[dimIndex]
+                length -= 1
+            qArea = q.area
+            qCargo = q.cargo
+            qPrevDimIndex = q.prev[dimIndex]
+            if length > 1:
+                hvol = qPrevDimIndex.volume[dimIndex] + qPrevDimIndex.area[dimIndex] * (
+                        qCargo[dimIndex] - qPrevDimIndex.cargo[dimIndex])
+            else:
+                qArea[0] = 1
+                qArea[1:dimIndex + 1] = [qArea[i] * -qCargo[i] for i in range(dimIndex)]
+            q.volume[dimIndex] = hvol
+            if q.ignore >= dimIndex:
+                qArea[dimIndex] = qPrevDimIndex.area[dimIndex]
+            else:
+                qArea[dimIndex] = hvRecursive(dimIndex - 1, length, bounds)
+                if qArea[dimIndex] <= qPrevDimIndex.area[dimIndex]:
+                    q.ignore = dimIndex
+            while p is not sentinel:
+                pCargoDimIndex = p.cargo[dimIndex]
+                hvol += q.area[dimIndex] * (pCargoDimIndex - q.cargo[dimIndex])
+                bounds[dimIndex] = pCargoDimIndex
+                reinsert(p, dimIndex, bounds)
+                length += 1
+                q = p
+                p = p.next[dimIndex]
+                q.volume[dimIndex] = hvol
+                if q.ignore >= dimIndex:
+                    q.area[dimIndex] = q.prev[dimIndex].area[dimIndex]
+                else:
+                    q.area[dimIndex] = hvRecursive(dimIndex - 1, length, bounds)
+                    if q.area[dimIndex] <= q.prev[dimIndex].area[dimIndex]:
+                        q.ignore = dimIndex
+            hvol -= q.area[dimIndex] * q.cargo[dimIndex]
+            return hvol
+
+    def preProcess(self, front):
+        """Sets up the list data structure needed for calculation."""
+        dimensions = len(self.referencePoint)
+        nodeList = MultiList(dimensions)
+        nodes = [MultiList.Node(dimensions, point) for point in front]
+        for i in range(dimensions):
+            self.sortByDimension(nodes, i)
+            nodeList.extend(nodes, i)
+        self.list = nodeList
+
+    def sortByDimension(self, nodes, i):
+        """Sorts the list of nodes by the i-th value of the contained points."""
+        # build a list of tuples of (point[i], node)
+        decorated = [(node.cargo[i], index, node) for index, node in enumerate(nodes)]
+        # sort by this value
+        decorated.sort()
+        # write back to original list
+        nodes[:] = [node for (_, _, node) in decorated]
+
+
+class MultiList:
+    """A special data structure needed by FonsecaHyperVolume.
+
+    It consists of several doubly linked lists that share common nodes. So,
+    every node has multiple predecessors and successors, one in every list.
+
+    """
+
+    class Node:
+
+        def __init__(self, numberLists, cargo=None):
+            self.cargo = cargo
+            self.next = [None] * numberLists
+            self.prev = [None] * numberLists
+            self.ignore = 0
+            self.area = [0.0] * numberLists
+            self.volume = [0.0] * numberLists
+
+        def __str__(self):
+            return str(self.cargo)
+
+    def __init__(self, numberLists):
+        """Constructor.
+
+        Builds 'numberLists' doubly linked lists.
+
+        """
+        self.numberLists = numberLists
+        self.sentinel = MultiList.Node(numberLists)
+        self.sentinel.next = [self.sentinel] * numberLists
+        self.sentinel.prev = [self.sentinel] * numberLists
+
+    def __str__(self):
+        strings = []
+        for i in range(self.numberLists):
+            currentList = []
+            node = self.sentinel.next[i]
+            while node != self.sentinel:
+                currentList.append(str(node))
+                node = node.next[i]
+            strings.append(str(currentList))
+        stringRepr = ""
+        for string in strings:
+            stringRepr += string + "\n"
+        return stringRepr
+
+    def __len__(self):
+        """Returns the number of lists that are included in this MultiList."""
+        return self.numberLists
+
+    def getLength(self, i):
+        """Returns the length of the i-th list."""
+        length = 0
+        sentinel = self.sentinel
+        node = sentinel.next[i]
+        while node != sentinel:
+            length += 1
+            node = node.next[i]
+        return length
+
+    def append(self, node, index):
+        """Appends a node to the end of the list at the given index."""
+        lastButOne = self.sentinel.prev[index]
+        node.next[index] = self.sentinel
+        node.prev[index] = lastButOne
+        # set the last element as the new one
+        self.sentinel.prev[index] = node
+        lastButOne.next[index] = node
+
+    def extend(self, nodes, index):
+        """Extends the list at the given index with the nodes."""
+        sentinel = self.sentinel
+        for node in nodes:
+            lastButOne = sentinel.prev[index]
+            node.next[index] = sentinel
+            node.prev[index] = lastButOne
+            # set the last element as the new one
+            sentinel.prev[index] = node
+            lastButOne.next[index] = node
+
+    def remove(self, node, index, bounds):
+        """Removes and returns 'node' from all lists in [0, 'index'[."""
+        for i in range(index):
+            predecessor = node.prev[i]
+            successor = node.next[i]
+            predecessor.next[i] = successor
+            successor.prev[i] = predecessor
+            if bounds[i] > node.cargo[i]:
+                bounds[i] = node.cargo[i]
+        return node
+
+    def reinsert(self, node, index, bounds):
+        """
+        Inserts 'node' at the position it had in all lists in [0, 'index'[
+        before it was removed. This method assumes that the next and previous
+        nodes of the node that is reinserted are in the list.
+
+        """
+        for i in range(index):
+            node.prev[i].next[i] = node
+            node.next[i].prev[i] = node
+            if bounds[i] > node.cargo[i]:
+                bounds[i] = node.cargo[i]
+
+
+if __name__ == "__main__":
+    # Example:
+    referencePoint = [2, 2, 2]
+    hv = HyperVolume(referencePoint)
+    front = [[1, 0, 1], [0, 1, 0]]
+    volume = hv.compute(front)

pymoo/vendor/vendor_cmaes.py

@@ -0,0 +1,412 @@
+import time
+
+import numpy as np
+from cma import CMAOptions
+from cma import optimization_tools as ot
+from cma.evolution_strategy import cma_default_options, CMAEvolutionStrategy
+from cma.utilities import utils
+from cma.utilities.math import Mh
+
+all_stoppings = []
+
+def void(_):
+    pass
+
+def my_fmin(x0,
+            sigma0,
+            objective_function=void,
+            options=None,
+            args=(),
+            gradf=None,
+            restarts=0,
+            restart_from_best='False',
+            incpopsize=2,
+            eval_initial_x=False,
+            parallel_objective=None,
+            noise_handler=None,
+            noise_change_sigma_exponent=1,
+            noise_kappa_exponent=0,  # TODO: add max kappa value as parameter
+            bipop=False,
+            callback=None):
+
+    if 1 < 3:  # try: # pass on KeyboardInterrupt
+        if not objective_function and not parallel_objective:  # cma.fmin(0, 0, 0)
+            return CMAOptions()  # these opts are by definition valid
+
+        fmin_options = locals().copy()  # archive original options
+        del fmin_options['objective_function']
+        del fmin_options['x0']
+        del fmin_options['sigma0']
+        del fmin_options['options']
+        del fmin_options['args']
+
+        if options is None:
+            options = cma_default_options
+        CMAOptions().check_attributes(options)  # might modify options
+        # checked that no options.ftarget =
+        opts = CMAOptions(options.copy()).complement()
+
+        if callback is None:
+            callback = []
+        elif callable(callback):
+            callback = [callback]
+
+        # BIPOP-related variables:
+        runs_with_small = 0
+        small_i = []
+        large_i = []
+        popsize0 = None  # to be evaluated after the first iteration
+        maxiter0 = None  # to be evaluated after the first iteration
+        base_evals = 0
+
+        irun = 0
+        best = ot.BestSolution()
+        all_stoppings = []
+        while True:  # restart loop
+            sigma_factor = 1
+
+            # Adjust the population according to BIPOP after a restart.
+            if not bipop:
+                # BIPOP not in use, simply double the previous population
+                # on restart.
+                if irun > 0:
+                    popsize_multiplier = fmin_options['incpopsize'] ** (irun - runs_with_small)
+                    opts['popsize'] = popsize0 * popsize_multiplier
+
+            elif irun == 0:
+                # Initial run is with "normal" population size; it is
+                # the large population before first doubling, but its
+                # budget accounting is the same as in case of small
+                # population.
+                poptype = 'small'
+
+            elif sum(small_i) < sum(large_i):
+                # An interweaved run with small population size
+                poptype = 'small'
+                if 11 < 3:  # not needed when compared to irun - runs_with_small
+                    restarts += 1  # A small restart doesn't count in the total
+                runs_with_small += 1  # _Before_ it's used in popsize_lastlarge
+
+                sigma_factor = 0.01 ** np.random.uniform()  # Local search
+                popsize_multiplier = fmin_options['incpopsize'] ** (irun - runs_with_small)
+                opts['popsize'] = np.floor(popsize0 * popsize_multiplier ** (np.random.uniform() ** 2))
+                opts['maxiter'] = min(maxiter0, 0.5 * sum(large_i) / opts['popsize'])
+                # print('small basemul %s --> %s; maxiter %s' % (popsize_multiplier, opts['popsize'], opts['maxiter']))
+
+            else:
+                # A run with large population size; the population
+                # doubling is implicit with incpopsize.
+                poptype = 'large'
+
+                popsize_multiplier = fmin_options['incpopsize'] ** (irun - runs_with_small)
+                opts['popsize'] = popsize0 * popsize_multiplier
+                opts['maxiter'] = maxiter0
+                # print('large basemul %s --> %s; maxiter %s' % (popsize_multiplier, opts['popsize'], opts['maxiter']))
+
+            if not callable(objective_function) and callable(parallel_objective):
+                def objective_function(x, *args):
+                    """created from `parallel_objective` argument"""
+                    return parallel_objective([x], *args)[0]
+
+            # recover from a CMA object
+            if irun == 0 and isinstance(x0, MyCMAEvolutionStrategy):
+                es = x0
+                x0 = es.inputargs['x0']  # for the next restarts
+                if np.isscalar(sigma0) and np.isfinite(sigma0) and sigma0 > 0:
+                    es.sigma = sigma0
+                # debatable whether this makes sense:
+                sigma0 = es.inputargs['sigma0']  # for the next restarts
+                if options is not None:
+                    es.opts.set(options)
+                # ignore further input args and keep original options
+            else:  # default case
+                if irun and eval(str(fmin_options['restart_from_best'])):
+                    utils.print_warning('CAVE: restart_from_best is often not useful',
+                                        verbose=opts['verbose'])
+                    es = MyCMAEvolutionStrategy(best.x, sigma_factor * sigma0, opts)
+                else:
+                    es = MyCMAEvolutionStrategy(x0, sigma_factor * sigma0, opts)
+                # return opts, es
+                if callable(objective_function) and (
+                        eval_initial_x
+                        or es.opts['CMA_elitist'] == 'initial'
+                        or (es.opts['CMA_elitist'] and
+                            eval_initial_x is None)):
+                    x = es.gp.pheno(es.mean,
+                                    into_bounds=es.boundary_handler.repair,
+                                    archive=es.sent_solutions)
+                    es.f0 = yield x
+                    es.best.update([x], es.sent_solutions,
+                                   [es.f0], 1)
+                    es.countevals += 1
+            es.objective_function = objective_function  # only for the record
+
+            opts = es.opts  # processed options, unambiguous
+            # a hack:
+            fmin_opts = CMAOptions("unchecked", **fmin_options.copy())
+            for k in fmin_opts:
+                # locals() cannot be modified directly, exec won't work
+                # in 3.x, therefore
+                fmin_opts.eval(k, loc={'N': es.N,
+                                       'popsize': opts['popsize']},
+                               correct_key=False)
+
+            es.logger.append = opts['verb_append'] or es.countiter > 0 or irun > 0
+            # es.logger is "the same" logger, because the "identity"
+            # is only determined by the `verb_filenameprefix` option
+            logger = es.logger  # shortcut
+            try:
+                logger.persistent_communication_dict.update(
+                    {'variable_annotations':
+                         objective_function.variable_annotations})
+            except AttributeError:
+                pass
+
+            if 11 < 3:
+                if es.countiter == 0 and es.opts['verb_log'] > 0 and \
+                        not es.opts['verb_append']:
+                    logger = CMADataLogger(es.opts['verb_filenameprefix']
+                                           ).register(es)
+                    logger.add()
+                es.writeOutput()  # initial values for sigma etc
+
+            if noise_handler:
+                if isinstance(noise_handler, type):
+                    noisehandler = noise_handler(es.N)
+                else:
+                    noisehandler = noise_handler
+                noise_handling = True
+                if fmin_opts['noise_change_sigma_exponent'] > 0:
+                    es.opts['tolfacupx'] = inf
+            else:
+                noisehandler = ot.NoiseHandler(es.N, 0)  # switched off
+                noise_handling = False
+            es.noise_handler = noisehandler
+
+            # the problem: this assumes that good solutions cannot take longer than bad ones:
+            # with EvalInParallel(objective_function, 2, is_feasible=opts['is_feasible']) as eval_in_parallel:
+            if 1 < 3:
+                while not es.stop():  # iteration loop
+                    # X, fit = eval_in_parallel(lambda: es.ask(1)[0], es.popsize, args, repetitions=noisehandler.evaluations-1)
+                    X, fit = yield from es.ask_and_eval(parallel_objective or objective_function,
+                                             args, gradf=gradf,
+                                             evaluations=noisehandler.evaluations,
+                                             aggregation=np.median,
+                                             parallel_mode=parallel_objective)  # treats NaN with resampling if not parallel_mode
+                    # TODO: check args and in case use args=(noisehandler.evaluations, )
+
+                    if 11 < 3 and opts['vv']:  # inject a solution
+                        # use option check_point = [0]
+                        if 0 * np.random.randn() >= 0:
+                            X[0] = 0 + opts['vv'] * es.sigma ** 0 * np.random.randn(es.N)
+                            fit[0] = yield X[0]
+                            # print fit[0]
+                    if es.opts['verbose'] > 4:  # may be undesirable with dynamic fitness (e.g. Augmented Lagrangian)
+                        if es.countiter < 2 or min(fit) <= es.best.last.f:
+                            degrading_iterations_count = 0  # comes first to avoid code check complaint
+                        else:  # min(fit) > es.best.last.f:
+                            degrading_iterations_count += 1
+                            if degrading_iterations_count > 4:
+                                utils.print_message('%d f-degrading iterations (set verbose<=4 to suppress)'
+                                                    % degrading_iterations_count,
+                                                    iteration=es.countiter)
+                    es.tell(X, fit)  # prepare for next iteration
+                    if noise_handling:  # it would be better to also use these f-evaluations in tell
+                        es.sigma *= noisehandler(X, fit, objective_function, es.ask,
+                                                 args=args) ** fmin_opts['noise_change_sigma_exponent']
+
+                        es.countevals += noisehandler.evaluations_just_done  # TODO: this is a hack, not important though
+                        # es.more_to_write.append(noisehandler.evaluations_just_done)
+                        if noisehandler.maxevals > noisehandler.minevals:
+                            es.more_to_write.append(noisehandler.evaluations)
+                        if 1 < 3:
+                            # If sigma was above multiplied by the same
+                            #  factor cmean is divided by here, this is
+                            #  like only multiplying kappa instead of
+                            #  changing cmean and sigma.
+                            es.sp.cmean *= np.exp(-noise_kappa_exponent * np.tanh(noisehandler.noiseS))
+                            es.sp.cmean[es.sp.cmean > 1] = 1.0  # also works with "scalar arrays" like np.array(1.2)
+                    for f in callback:
+                        f is None or f(es)
+                    es.disp()
+                    logger.add(
+                        # more_data=[noisehandler.evaluations, 10**noisehandler.noiseS] if noise_handling else [],
+                        modulo=1 if es.stop() and logger.modulo else None)
+                    if (opts['verb_log'] and opts['verb_plot'] and
+                            (es.countiter % max(opts['verb_plot'], opts['verb_log']) == 0 or es.stop())):
+                        logger.plot(324)
+
+            # end while not es.stop
+            if opts['eval_final_mean'] and callable(objective_function):
+                mean_pheno = es.gp.pheno(es.mean,
+                                         into_bounds=es.boundary_handler.repair,
+                                         archive=es.sent_solutions)
+                fmean = yield mean_pheno
+                es.countevals += 1
+                es.best.update([mean_pheno], es.sent_solutions, [fmean], es.countevals)
+
+            best.update(es.best, es.sent_solutions)  # in restarted case
+            # es.best.update(best)
+
+            this_evals = es.countevals - base_evals
+            base_evals = es.countevals
+
+            # BIPOP stats update
+
+            if irun == 0:
+                popsize0 = opts['popsize']
+                maxiter0 = opts['maxiter']
+                # XXX: This might be a bug? Reproduced from Matlab
+                # small_i.append(this_evals)
+
+            if bipop:
+                if poptype == 'small':
+                    small_i.append(this_evals)
+                else:  # poptype == 'large'
+                    large_i.append(this_evals)
+
+            # final message
+            if opts['verb_disp']:
+                es.result_pretty(irun, time.asctime(time.localtime()),
+                                 best.f)
+
+            irun += 1
+            # if irun > fmin_opts['restarts'] or 'ftarget' in es.stop() \
+            # if irun > restarts or 'ftarget' in es.stop() \
+            all_stoppings.append(dict(es.stop(check=False)))  # keeping the order
+            if irun - runs_with_small > fmin_opts['restarts'] or 'ftarget' in es.stop() \
+                    or 'maxfevals' in es.stop(check=False) or 'callback' in es.stop(check=False):
+                break
+            opts['verb_append'] = es.countevals
+            opts['popsize'] = fmin_opts['incpopsize'] * es.sp.popsize  # TODO: use rather options?
+            try:
+                opts['seed'] += 1
+            except TypeError:
+                pass
+
+        # while irun
+
+        # es.out['best'] = best  # TODO: this is a rather suboptimal type for inspection in the shell
+        if irun:
+            es.best.update(best)
+            # TODO: there should be a better way to communicate the overall best
+        return es.result + (es.stop(), es, logger)
+        ### 4560
+        # TODO refine output, can #args be flexible?
+        # is this well usable as it is now?
+    else:  # except KeyboardInterrupt:  # Exception as e:
+        if eval(safe_str(options['verb_disp'])) > 0:
+            print(' in/outcomment ``raise`` in last line of cma.fmin to prevent/restore KeyboardInterrupt exception')
+        raise KeyboardInterrupt  # cave: swallowing this exception can silently mess up experiments, if ctrl-C is hit
+
+
+class MyCMAEvolutionStrategy(CMAEvolutionStrategy):
+
+    def ask_and_eval(self, func, args=(), gradf=None, number=None, xmean=None, sigma_fac=1,
+                     evaluations=1, aggregation=np.median, kappa=1, parallel_mode=False):
+
+        # initialize
+        popsize = self.sp.popsize
+        if number is not None:
+            popsize = int(number)
+
+        if self.opts['CMA_mirrormethod'] == 1:  # direct selective mirrors
+            nmirrors = Mh.sround(self.sp.lam_mirr * popsize / self.sp.popsize)
+            self._mirrormethod1_done = self.countiter
+        else:
+            # method==0 unconditional mirrors are done in ask_geno
+            # method==2 delayed selective mirrors are done via injection
+            nmirrors = 0
+        assert nmirrors <= popsize // 2
+        self.mirrors_idx = np.arange(nmirrors)  # might never be used
+        is_feasible = self.opts['is_feasible']
+
+        # do the work
+        fit = []  # or np.NaN * np.empty(number)
+        X_first = self.ask(popsize, xmean=xmean, gradf=gradf, args=args)
+        if xmean is None:
+            xmean = self.mean  # might have changed in self.ask
+        X = []
+        if parallel_mode:
+            if hasattr(func, 'evaluations'):
+                evals0 = func.evaluations
+            fit_first = yield X_first
+            # the rest is only book keeping and warnings spitting
+            if hasattr(func, 'evaluations'):
+                self.countevals += func.evaluations - evals0 - self.popsize  # why not .sp.popsize ?
+            if nmirrors and self.opts['CMA_mirrormethod'] > 0 and self.countiter < 2:
+                utils.print_warning(
+                    "selective mirrors will not work in parallel mode",
+                    "ask_and_eval", "CMAEvolutionStrategy")
+            if evaluations > 1 and self.countiter < 2:
+                utils.print_warning(
+                    "aggregating evaluations will not work in parallel mode",
+                    "ask_and_eval", "CMAEvolutionStrategy")
+        else:
+            fit_first = len(X_first) * [None]
+        for k in range(popsize):
+            x, f = X_first.pop(0), fit_first.pop(0)
+            rejected = -1
+            while f is None or not is_feasible(x, f):  # rejection sampling
+                if parallel_mode:
+                    utils.print_warning(
+                        "rejection sampling will not work in parallel mode"
+                        " unless the parallel_objective makes a distinction\n"
+                        "between called with a numpy array vs a list (of"
+                        " numpy arrays) as first argument.",
+                        "ask_and_eval", "CMAEvolutionStrategy")
+                rejected += 1
+                if rejected:  # resample
+                    x = self.ask(1, xmean, sigma_fac)[0]
+                elif k >= popsize - nmirrors:  # selective mirrors
+                    if k == popsize - nmirrors:
+                        self.mirrors_idx = np.argsort(fit)[-1:-1 - nmirrors:-1]
+                    x = self.get_mirror(X[self.mirrors_idx[popsize - 1 - k]])
+
+                # constraints handling test hardwired ccccccccccc
+
+                length_normalizer = 1
+                # zzzzzzzzzzzzzzzzzzzzzzzzz
+                if 11 < 3:
+                    # for some unclear reason, this normalization does not work as expected: the step-size
+                    # becomes sometimes too large and overall the mean might diverge. Is the reason that
+                    # we observe random fluctuations, because the length is not selection relevant?
+                    # However sigma-adaptation should mainly work on the correlation, not the length?
+                    # Or is the reason the deviation of the direction introduced by using the original
+                    # length, which also can effect the measured correlation?
+                    # Update: if the length of z in CSA is clipped at chiN+1, it works, but only sometimes?
+                    length_normalizer = self.N**0.5 / self.mahalanobis_norm(x - xmean)  # self.const.chiN < N**0.5, the constant here is irrelevant (absorbed by kappa)
+                    # print(self.N**0.5 / self.mahalanobis_norm(x - xmean))
+                    # self.more_to_write += [length_normalizer * 1e-3, length_normalizer * self.mahalanobis_norm(x - xmean) * 1e2]
+                    if kappa == 1:
+                        f = yield x
+                    else:
+                        f = yield xmean + kappa * length_normalizer * (x - xmean)
+
+                if is_feasible(x, f) and evaluations > 1:
+                    if kappa == 1:
+                        _f = yield x
+                        f = aggregation([f] + [_f])
+                    else:
+                        _f = []
+                        for _i in range(int(evaluations - 1)):
+                            v = yield xmean + kappa * length_normalizer * (x - xmean)
+                            _f.append(v)
+                        f = aggregation([f] + _f)
+
+                if (rejected + 1) % 1000 == 0:
+                    utils.print_warning('  %d solutions rejected (f-value NaN or None) at iteration %d' %
+                          (rejected, self.countiter))
+            fit.append(f)
+            X.append(x)
+        self.evaluations_per_f_value = int(evaluations)
+        if any(f is None or utils.is_nan(f) for f in fit):
+            idxs = [i for i in range(len(fit))
+                    if fit[i] is None or utils.is_nan(fit[i])]
+            utils.print_warning("f-values %s contain None or NaN at indices %s"
+                                % (str(fit[:30]) + ('...' if len(fit) > 30 else ''),
+                                   str(idxs)),
+                                'ask_and_tell',
+                                'CMAEvolutionStrategy',
+                                self.countiter)
+        return X, fit