fcmaes 1.3.17__py3-none-any.whl → 1.6.9__py3-none-any.whl

fcmaes/cmaescpp.py

@@ -13,26 +13,32 @@ import os
 import math
 import ctypes as ct
 import numpy as np
-from numpy.random import MT19937, Generator
-from scipy.optimize import OptimizeResult
-from fcmaes.cmaes import _check_bounds
-from fcmaes.decpp import mo_call_back_type, callback, libcmalib
+from numpy.random import PCG64DXSM, Generator
+from scipy.optimize import OptimizeResult, Bounds
+from fcmaes.evaluator import _check_bounds, _get_bounds, mo_call_back_type, callback_so, callback_par, call_back_par, parallel, libcmalib
+
+from typing import Optional, Callable, Union
+from numpy.typing import ArrayLike
 
 os.environ['MKL_DEBUG_CPU_TYPE'] = '5'
 
-def minimize(fun, 
-             bounds=None, 
-             x0=None, 
-             input_sigma = 0.3, 
-             popsize = 31, 
-             max_evaluations = 100000, 
-             accuracy = 1.0, 
-             stop_fitness = None, 
-             rg = Generator(MT19937()),
-             runid=0,
-             workers = 1, 
-             normalize = True,
-             update_gap = None):   
+def minimize(fun: Callable[[ArrayLike], float], 
+             bounds: Optional[Bounds] = None, 
+             x0: Optional[ArrayLike] = None,
+             input_sigma: Optional[Union[float, ArrayLike, Callable]] = 0.3,
+             popsize: Optional[int] = 31,
+             max_evaluations: Optional[int]  = 100000,
+             accuracy: Optional[float] = 1.0, 
+             stop_fitness: Optional[float] = -np.inf, 
+             stop_hist: Optional[float] = -1,
+             rg: Optional[Generator] = Generator(PCG64DXSM()),
+             runid: Optional[int] = 0,
+             workers: Optional[int] = 1, 
+             normalize: Optional[bool] = True,
+             delayed_update: Optional[bool] = True,
+             update_gap: Optional[int] = None
+             ) -> OptimizeResult:
+   
     """Minimization of a scalar function of one or more variables using a 
     C++ CMA-ES implementation called via ctypes.
      
@@ -40,10 +46,8 @@ def minimize(fun,
     ----------
     fun : callable
         The objective function to be minimized.
-            ``fun(x, *args) -> float``
-        where ``x`` is an 1-D array with shape (dim,) and ``args``
-        is a tuple of the fixed parameters needed to completely
-        specify the function.
+            ``fun(x) -> float``
+        where ``x`` is an 1-D array with shape (dim,)
     bounds : sequence or `Bounds`, optional
         Bounds on variables. There are two ways to specify the bounds:
             1. Instance of the `scipy.Bounds` class.
@@ -62,6 +66,9 @@ def minimize(fun,
         values > 1.0 reduce the accuracy.
     stop_fitness : float, optional 
          Limit for fitness value. If reached minimize terminates.
+    stop_hist : float, optional 
+         Set to 0 if you want to prevent premature termination because 
+         there is no progress
     rg = numpy.random.Generator, optional
         Random generator for creating random guesses.
     runid : int, optional
@@ -70,7 +77,9 @@ def minimize(fun,
         If not workers is None, function evaluation is performed in parallel for the whole population. 
         Useful for costly objective functions but is deactivated for parallel retry.      
     normalize : boolean, optional
-        pheno -> if true geno transformation maps arguments to interval [-1,1] 
+        if true pheno -> geno transformation maps arguments to interval [-1,1]
+    delayed_update : boolean, optional
+        if true uses delayed update / C++ parallelism, i false uses Python multithreading
     update_gap : int, optional
         number of iterations without distribution update
            
@@ -87,9 +96,6 @@ def minimize(fun,
     
     lower, upper, guess = _check_bounds(bounds, x0, rg)      
     dim = guess.size   
-    if lower is None:
-        lower = [0]*dim
-        upper = [0]*dim
     if workers is None:
         workers = 0
     mu = int(popsize/2)
@@ -97,31 +103,217 @@ def minimize(fun,
         input_sigma=input_sigma()
     if np.ndim(input_sigma) == 0:
         input_sigma = [input_sigma] * dim
-    if stop_fitness is None:
-        stop_fitness = math.inf    
+    if stop_hist is None:
+        stop_hist = -1;
     array_type = ct.c_double * dim 
-    c_callback = mo_call_back_type(callback(fun, dim))
+    c_callback = mo_call_back_type(callback_so(fun, dim))
+    parfun = None if delayed_update == True or workers is None or workers <= 1 else parallel(fun, workers)
+    c_callback_par = call_back_par(callback_par(fun, parfun))
     res = np.empty(dim+4)
     res_p = res.ctypes.data_as(ct.POINTER(ct.c_double))
     try:
-        optimizeACMA_C(runid, c_callback, dim, array_type(*guess), array_type(*lower), array_type(*upper), 
-                array_type(*input_sigma), max_evaluations, stop_fitness, mu, 
-                popsize, accuracy, int(rg.uniform(0, 2**32 - 1)), normalize, -1 if update_gap is None else update_gap, 
+        optimizeACMA_C(runid, c_callback, c_callback_par, 
+                dim, array_type(*guess), 
+                None if lower is None else array_type(*lower), 
+                None if upper is None else array_type(*upper), 
+                array_type(*input_sigma), max_evaluations, stop_fitness, stop_hist, mu, 
+                popsize, accuracy, int(rg.uniform(0, 2**32 - 1)), 
+                normalize, delayed_update, -1 if update_gap is None else update_gap,
                 workers, res_p)
         x = res[:dim]
         val = res[dim]
         evals = int(res[dim+1])
         iterations = int(res[dim+2])
         stop = int(res[dim+3])
-        return OptimizeResult(x=x, fun=val, nfev=evals, nit=iterations, status=stop, success=True)
+        res = OptimizeResult(x=x, fun=val, nfev=evals, nit=iterations, status=stop, success=True)
     except Exception as ex:
-        return OptimizeResult(x=None, fun=sys.float_info.max, nfev=0, nit=0, status=-1, success=False)
+        res = OptimizeResult(x=None, fun=sys.float_info.max, nfev=0, nit=0, status=-1, success=False)
+    if not parfun is None:
+        parfun.stop()
+    return res
+
+class ACMA_C:
+
+    def __init__(self,
+        dim, 
+        bounds: Optional[Bounds] = None, 
+        x0: Optional[ArrayLike] = None,
+        input_sigma: Optional[Union[float, ArrayLike, Callable]] = 0.3, 
+        popsize: Optional[int] = 31,  
+        max_evaluations: Optional[int] = 100000, 
+        accuracy: Optional[float] = 1.0, 
+        stop_fitness: Optional[float] = -np.inf, 
+        stop_hist: Optional[float] = -1,
+        rg: Optional[Generator] = Generator(PCG64DXSM()),
+        runid: Optional[int] = 0,
+        normalize: Optional[bool] = True,
+        delayed_update: Optional[bool] = True,
+        update_gap: Optional[int] = None
+     ):
+       
+        """Parameters
+        ----------
+        dim : int
+            dimension of the argument of the objective function
+        bounds : sequence or `Bounds`, optional
+            Bounds on variables. There are two ways to specify the bounds:
+                1. Instance of the `scipy.Bounds` class.
+                2. Sequence of ``(min, max)`` pairs for each element in `x`. None
+                   is used to specify no bound.
+        x0 : ndarray, shape (dim,)
+            Initial guess. Array of real elements of size (dim,),
+            where 'dim' is the number of independent variables.  
+        input_sigma : ndarray, shape (dim,) or scalar
+            Initial step size for each dimension.
+        popsize = int, optional
+            CMA-ES population size.
+        max_evaluations : int, optional
+            Forced termination after ``max_evaluations`` function evaluations.
+        accuracy : float, optional
+            values > 1.0 reduce the accuracy.
+        stop_fitness : float, optional 
+             Limit for fitness value. If reached minimize terminates.
+        stop_hist : float, optional 
+             Set to 0 if you want to prevent premature termination because 
+             there is no progress
+        rg = numpy.random.Generator, optional
+            Random generator for creating random guesses.
+        runid : int, optional
+            id used by the is_terminate callback to identify the CMA-ES run.     
+        normalize : boolean, optional
+            if true pheno -> geno transformation maps arguments to interval [-1,1]
+        delayed_update : boolean, optional
+            if true uses delayed update / C++ parallelism, i false uses Python multithreading
+        update_gap : int, optional
+            number of iterations without distribution update"""
+             
+        lower, upper, guess = _get_bounds(dim, bounds, x0, rg)     
+        if lower is None:
+            lower = [0]*dim
+            upper = [0]*dim
+        mu = int(popsize/2)
+        if callable(input_sigma):
+            input_sigma=input_sigma()
+        if np.ndim(input_sigma) == 0:
+            input_sigma = [input_sigma] * dim
+        if stop_hist is None:
+            stop_hist = -1;
+        array_type = ct.c_double * dim 
+        try:
+            self.ptr = initACMA_C(runid,
+                dim, array_type(*guess), array_type(*lower), array_type(*upper), 
+                array_type(*input_sigma), max_evaluations, stop_fitness, stop_hist, mu, 
+                popsize, accuracy, int(rg.uniform(0, 2**32 - 1)), 
+                normalize, delayed_update, -1 if update_gap is None else update_gap)
+            self.popsize = popsize
+            self.dim = dim            
+        except Exception as ex:
+            print (ex)
+            pass
+    
+    def __del__(self):
+        destroyACMA_C(self.ptr)
+            
+    def ask(self) -> np.array:
+        try:
+            popsize = self.popsize
+            n = self.dim
+            res = np.empty(popsize*n)
+            res_p = res.ctypes.data_as(ct.POINTER(ct.c_double))
+            askACMA_C(self.ptr, res_p)
+            xs = np.empty((popsize, n))
+            for p in range(popsize):
+                xs[p,:] = res[p*n : (p+1)*n]
+            return xs
+        except Exception as ex:
+            print (ex)
+            return None
 
-optimizeACMA_C = libcmalib.optimizeACMA_C
-optimizeACMA_C.argtypes = [ct.c_long, mo_call_back_type, ct.c_int, \
-            ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), \
-            ct.POINTER(ct.c_double), ct.c_int, ct.c_double, ct.c_int, ct.c_int, \
-            ct.c_double, ct.c_long, ct.c_bool, ct.c_int, 
-            ct.c_int, ct.POINTER(ct.c_double)]
+    def tell(self, 
+             ys: np.ndarray, 
+             xs: Optional[np.ndarray] = None) -> int:  
+        if not xs is None:
+            return self.tell_x_(ys, xs)
+        try:
+            array_type_ys = ct.c_double * len(ys)
+            return tellACMA_C(self.ptr, array_type_ys(*ys))
+        except Exception as ex:
+            print (ex)
+            return -1    
 
+    def tell_x_(self, ys: np.ndarray, xs: np.ndarray):
+        try:
+            flat_xs = xs.flatten()
+            array_type_xs = ct.c_double * len(flat_xs)
+            array_type_ys = ct.c_double * len(ys)
+            return tellXACMA_C(self.ptr, array_type_ys(*ys), array_type_xs(*flat_xs))
+        except Exception as ex:
+            print (ex)
+            return -1 
+        
+    def population(self) -> np.array:
+        try:
+            popsize = self.popsize
+            n = self.dim
+            res = np.empty(popsize*n)
+            res_p = res.ctypes.data_as(ct.POINTER(ct.c_double))
+            populationACMA_C(self.ptr, res_p)
+            xs = np.array(popsize, n)
+            for p in range(popsize):
+                xs[p] = res[p*n : (p+1)*n]
+                return xs
+        except Exception as ex:
+            print (ex)
+            return None
 
+    def result(self) -> OptimizeResult:
+        res = np.empty(self.dim+4)
+        res_p = res.ctypes.data_as(ct.POINTER(ct.c_double))
+        try:
+            resultACMA_C(self.ptr, res_p)
+            x = res[:self.dim]
+            val = res[self.dim]
+            evals = int(res[self.dim+1])
+            iterations = int(res[self.dim+2])
+            stop = int(res[self.dim+3])
+            res = OptimizeResult(x=x, fun=val, nfev=evals, nit=iterations, status=stop, success=True)
+        except Exception as ex:
+            res = OptimizeResult(x=None, fun=sys.float_info.max, nfev=0, nit=0, status=-1, success=False)
+        return res
+
+if not libcmalib is None: 
+
+    optimizeACMA_C = libcmalib.optimizeACMA_C
+    optimizeACMA_C.argtypes = [ct.c_long, mo_call_back_type, call_back_par, ct.c_int, \
+                ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), \
+                ct.POINTER(ct.c_double), ct.c_int, ct.c_double, ct.c_double, ct.c_int, ct.c_int, \
+                ct.c_double, ct.c_long, ct.c_bool, ct.c_bool, ct.c_int, 
+                ct.c_int, ct.POINTER(ct.c_double)]
+    
+    initACMA_C = libcmalib.initACMA_C
+    initACMA_C.argtypes = [ct.c_long, ct.c_int, \
+                ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), \
+                ct.POINTER(ct.c_double), ct.c_int, ct.c_double, ct.c_double, ct.c_int, 
+                ct.c_int, ct.c_double, ct.c_long, ct.c_bool, ct.c_bool, ct.c_int]
+                    
+    initACMA_C.restype = ct.c_void_p   
+    
+    destroyACMA_C = libcmalib.destroyACMA_C
+    destroyACMA_C.argtypes = [ct.c_void_p]
+    
+    askACMA_C = libcmalib.askACMA_C
+    askACMA_C.argtypes = [ct.c_void_p, ct.POINTER(ct.c_double)]
+    
+    tellACMA_C = libcmalib.tellACMA_C
+    tellACMA_C.argtypes = [ct.c_void_p, ct.POINTER(ct.c_double)]
+    tellACMA_C.restype = ct.c_int
+    
+    tellXACMA_C = libcmalib.tellXACMA_C
+    tellXACMA_C.argtypes = [ct.c_void_p, ct.POINTER(ct.c_double), ct.POINTER(ct.c_double)]
+    tellXACMA_C.restype = ct.c_int
+    
+    populationACMA_C = libcmalib.populationACMA_C
+    populationACMA_C.argtypes = [ct.c_void_p, ct.POINTER(ct.c_double)]
+    
+    resultACMA_C = libcmalib.resultACMA_C
+    resultACMA_C.argtypes = [ct.c_void_p, ct.POINTER(ct.c_double)]

fcmaes/crfmnes.py

@@ -0,0 +1,339 @@
+
+import math
+import numpy as np
+import os
+from scipy.optimize import OptimizeResult, Bounds
+from numpy.random import PCG64DXSM, Generator
+from fcmaes.evaluator import _get_bounds, _fitness, serial, parallel
+
+from typing import Optional, Callable, Union, Dict
+from numpy.typing import ArrayLike
+
+""" Numpy based implementation of Fast Moving Natural Evolution Strategy 
+    for High-Dimensional Problems (CR-FM-NES), see https://arxiv.org/abs/2201.11422 .
+    Derived from https://github.com/nomuramasahir0/crfmnes .
+"""
+
+# evaluation value of the infeasible solution
+INFEASIBLE = np.inf
+
+os.environ['MKL_DEBUG_CPU_TYPE'] = '5'
+
+def minimize(fun: Callable[[ArrayLike], float],
+             bounds: Optional[Bounds] = None,
+             x0: Optional[ArrayLike] = None,
+             input_sigma: Optional[float] = 0.3,
+             popsize: Optional[int] = 32,
+             max_evaluations: Optional[int] = 100000,
+             workers: Optional[int] = None,
+             stop_fitness: Optional[float] = -np.inf,
+             is_terminate: Optional[Callable[[ArrayLike, float], bool]] = None,
+             rg: Optional[Generator] = Generator(PCG64DXSM()),
+             runid: Optional[int] = 0,
+             normalize: Optional[bool] = False,
+             options: Optional[Dict] = {}
+             ) -> OptimizeResult:       
+    """Minimization of a scalar function of one or more variables using CMA-ES.
+     
+    Parameters
+    ----------
+    fun : callable
+        The objective function to be minimized.
+            ``fun(x) -> float``
+        where ``x`` is an 1-D array with shape (n,)
+    bounds : sequence or `Bounds`, optional
+        Bounds on variables. There are two ways to specify the bounds:
+            1. Instance of the `scipy.Bounds` class.
+            2. Sequence of ``(min, max)`` pairs for each element in `x`. None
+               is used to specify no bound.
+    x0 : ndarray, shape (n,)
+        Initial guess. Array of real elements of size (n,),
+        where 'n' is the number of independent variables.  
+    input_sigma : ndarray, shape (n,) or scalar
+        Initial step size.
+    popsize = int, optional
+        CMA-ES population size.
+    max_evaluations : int, optional
+        Forced termination after ``max_evaluations`` function evaluations.
+    workers : int or None, optional
+        If not workers is None, function evaluation is performed in parallel for the whole population. 
+        Useful for costly objective functions but is deactivated for parallel retry.     
+    stop_fitness : float, optional 
+         Limit for fitness value. If reached minimize terminates.
+    is_terminate : callable, optional
+        Callback to be used if the caller of minimize wants to 
+        decide when to terminate. 
+    rg = numpy.random.Generator, optional
+        Random generator for creating random guesses.
+    runid : int, optional
+        id used by the is_terminate callback to identify the optimization run.
+    normalize : boolean, optional
+        if true pheno -> geno transformation maps arguments to interval [-1,1]  
+    options : dict, optional
+   
+    Returns
+    -------
+    res : scipy.OptimizeResult
+        The optimization result is represented as an ``OptimizeResult`` object"""
+
+    cr = CRFMNES(None, bounds, x0, input_sigma, popsize, 
+                 max_evaluations, stop_fitness, is_terminate, runid, normalize, options, rg, workers, fun)
+    
+    cr.optimize()
+
+    return OptimizeResult(x=cr.f.decode(cr.x_best), fun=cr.f_best, nfev=cr.no_of_evals, 
+                          nit=cr.g, status=cr.stop, 
+                          success=True)
+
+class CRFMNES:
+    
+    def __init__(self, 
+                dim = None, 
+                bounds: Optional[Bounds] = None, 
+                x0: Optional[ArrayLike] = None,
+                input_sigma: Optional[Union[float, ArrayLike, Callable]] = 0.3, 
+                popsize: Optional[int] = 32,  
+                max_evaluations: Optional[int] = 100000, 
+                stop_fitness: Optional[float] = -np.inf, 
+                is_terminate: Optional[bool] = None, 
+                runid: Optional[int] = 0, 
+                normalize: Optional[bool] = False,
+                options: Optional[Dict] = {}, 
+                rg: Optional[Generator] = Generator(PCG64DXSM()), 
+                workers: Optional[int] = None, 
+                fun: Optional[Callable[[ArrayLike], float]] = lambda x: 0): 
+        
+        if popsize is None:
+            popsize = 32         
+        if popsize % 2 == 1: # requires even popsize
+            popsize += 1
+        if dim is None:
+            if not x0 is None: dim = len(x0)
+            else: 
+                if not bounds is None: dim = len(bounds.lb)
+        lower, upper, guess = _get_bounds(dim, bounds, x0, rg) 
+        self.fun = serial(fun) if (workers is None or workers <= 1) else parallel(fun, workers)  
+        self.f = _fitness(self.fun, lower, upper, normalize)       
+        if options is None:
+            options = {}
+        if not lower is None:
+            options['constraint'] = [ [lower[i], upper[i]] for i in range(dim)]   
+        self.constraint = options.get('constraint', [[-np.inf, np.inf] for _ in range(dim)])
+        if 'seed' in options.keys():
+            np.random.seed(options['seed'])
+        sigma = input_sigma
+        if not np.isscalar(sigma):
+            sigma = np.mean(sigma)         
+        self.m = np.array([self.f.encode(guess)]).T
+
+        self.dim = dim
+        self.sigma = sigma
+        self.popsize = popsize
+              
+        self.max_evaluations = max_evaluations
+        self.stop_fitness = stop_fitness
+        self.is_terminate = is_terminate
+        self.rg = rg
+        self.runid = runid
+
+        self.v = options.get('v', self.rg.normal(0,1,(dim, 1)) / np.sqrt(dim))
+        
+        self.D = np.ones([dim, 1])
+        self.penalty_coef = options.get('penalty_coef', 1e5)
+        self.use_constraint_violation = options.get('use_constraint_violation', True)
+
+        self.w_rank_hat = (np.log(self.popsize / 2 + 1) - np.log(np.arange(1, self.popsize + 1))).reshape(self.popsize, 1)
+        self.w_rank_hat[np.where(self.w_rank_hat < 0)] = 0
+        self.w_rank = self.w_rank_hat / sum(self.w_rank_hat) - (1. / self.popsize)
+        self.mueff = 1 / ((self.w_rank + (1 / self.popsize)).T @ (self.w_rank + (1 / self.popsize)))[0][0]
+        self.cs = (self.mueff + 2.) / (self.dim + self.mueff + 5.)
+        self.cc = (4. + self.mueff / self.dim) / (self.dim + 4. + 2. * self.mueff / self.dim)
+        self.c1_cma = 2. / (math.pow(self.dim + 1.3, 2) + self.mueff)
+        # initialization
+        self.chiN = np.sqrt(self.dim) * (1. - 1. / (4. * self.dim) + 1. / (21. * self.dim * self.dim))
+        self.pc = np.zeros([self.dim, 1])
+        self.ps = np.zeros([self.dim, 1])
+        # distance weight parameter
+        self.h_inv = get_h_inv(self.dim)
+        self.alpha_dist = lambda lambF: self.h_inv * min(1., math.sqrt(self.popsize / self.dim)) * math.sqrt(
+            lambF / self.popsize)
+        self.w_dist_hat = lambda z, lambF: exp(self.alpha_dist(lambF) * np.linalg.norm(z))
+        # learning rate
+        self.eta_m = 1.0
+        self.eta_move_sigma = 1.
+        self.eta_stag_sigma = lambda lambF: math.tanh((0.024 * lambF + 0.7 * self.dim + 20.) / (self.dim + 12.))
+        self.eta_conv_sigma = lambda lambF: 2. * math.tanh((0.025 * lambF + 0.75 * self.dim + 10.) / (self.dim + 4.))
+        self.c1 = lambda lambF: self.c1_cma * (self.dim - 5) / 6 * (lambF / self.popsize)
+        self.eta_B = lambda lambF: np.tanh((min(0.02 * lambF, 3 * np.log(self.dim)) + 5) / (0.23 * self.dim + 25))
+
+        self.g = 0
+        self.no_of_evals = 0
+        self.iteration = 0
+        self.stop = 0
+
+        self.idxp = np.arange(self.popsize / 2, dtype=int)
+        self.idxm = np.arange(self.popsize / 2, self.popsize, dtype=int)
+        self.z = np.zeros([self.dim, self.popsize])
+
+        self.f_best = float('inf')
+        self.x_best = np.empty(self.dim)
+
+    def __del__(self):
+        if isinstance(self.fun, parallel):
+            self.fun.stop()
+        
+    def calc_violations(self, x):
+        violations = np.zeros(self.popsize)
+        for i in range(self.popsize):
+            for j in range(self.dim):
+                violations[i] += (- min(0, x[j][i] - self.constraint[j][0]) + max(0, x[j][i] - self.constraint[j][1])) * self.penalty_coef
+        return violations
+
+    def optimize(self) -> int:
+        # -------------------- Generation Loop --------------------------------
+        while True:
+            if self.no_of_evals > self.max_evaluations:
+                break
+            if self.stop != 0:
+                break
+            try:
+                x = self.ask()
+                y = self.f.values(self.f.decode(self.f.closestFeasible(x)))
+                self.tell(y)
+                if self.stop != 0:
+                    break 
+            except Exception as ex:
+                self.stop = -1
+                break
+
+    def ask(self) -> np.ndarray:
+        d = self.dim
+        popsize = self.popsize
+        zhalf = self.rg.normal(0,1,(d, int(popsize / 2)))  # dim x popsize/2
+        self.z[:, self.idxp] = zhalf
+        self.z[:, self.idxm] = -zhalf
+        self.normv = np.linalg.norm(self.v)
+        self.normv2 = self.normv ** 2
+        self.vbar = self.v / self.normv
+        self.y = self.z + ((np.sqrt(1 + self.normv2) - 1) * (self.vbar @ (self.vbar.T @ self.z)))
+        self.x = self.m + (self.sigma * self.y) * self.D
+        return self.x.T
+
+    def tell(self, evals_no_sort: np.ndarray) -> int:
+        violations = np.zeros(self.popsize)
+        if self.use_constraint_violation:
+            violations = self.calc_violations(self.x)
+            sorted_indices = sort_indices_by(evals_no_sort + violations, self.z)
+        else:
+            sorted_indices = sort_indices_by(evals_no_sort, self.z)
+        best_eval_id = sorted_indices[0]
+        f_best = evals_no_sort[best_eval_id]
+        x_best = self.x[:, best_eval_id]
+        self.z = self.z[:, sorted_indices]
+        y = self.y[:, sorted_indices]
+        x = self.x[:, sorted_indices]
+
+        self.no_of_evals += self.popsize
+        self.g += 1
+ 
+        if f_best < self.f_best:
+            self.f_best = f_best
+            self.x_best = x_best           
+            # print(self.no_of_evals, self.g, self.f_best)
+
+        # This operation assumes that if the solution is infeasible, infinity comes in as input.
+        lambF = np.sum(evals_no_sort < np.finfo(float).max)
+
+        # evolution path p_sigma
+        self.ps = (1 - self.cs) * self.ps + np.sqrt(self.cs * (2. - self.cs) * self.mueff) * (self.z @ self.w_rank)
+        ps_norm = np.linalg.norm(self.ps)
+        # distance weight
+        f1 =  self.h_inv * min(1., math.sqrt(self.popsize / self.dim)) * math.sqrt(lambF / self.popsize)        
+        w_tmp = self.w_rank_hat * np.exp(np.linalg.norm(self.z, axis = 0) * f1).reshape((self.popsize,1))
+        weights_dist = w_tmp / sum(w_tmp) - 1. / self.popsize
+        # switching weights and learning rate
+        weights = weights_dist if ps_norm >= self.chiN else self.w_rank
+        eta_sigma = self.eta_move_sigma if ps_norm >= self.chiN else self.eta_stag_sigma(
+            lambF) if ps_norm >= 0.1 * self.chiN else self.eta_conv_sigma(lambF)
+        # update pc, m
+        wxm = (x - self.m) @ weights
+        self.pc = (1. - self.cc) * self.pc + np.sqrt(self.cc * (2. - self.cc) * self.mueff) * wxm / self.sigma
+        self.m += self.eta_m * wxm
+        # calculate s, t
+        # step1
+        normv4 = self.normv2 ** 2
+        exY = np.append(y, self.pc / self.D, axis=1)  # dim x popsize+1
+        yy = exY * exY  # dim x popsize+1
+        ip_yvbar = self.vbar.T @ exY
+        yvbar = exY * self.vbar  # dim x popsize+1. exYのそれぞれの列にvbarがかかる
+        gammav = 1. + self.normv2
+        vbarbar = self.vbar * self.vbar
+        alphavd = min(1, np.sqrt(normv4 + (2 * gammav - np.sqrt(gammav)) / np.max(vbarbar)) / (2 + self.normv2))  # scalar
+        
+        t = exY * ip_yvbar - self.vbar * (ip_yvbar ** 2 + gammav) / 2  # dim x popsize+1
+        b = -(1 - alphavd ** 2) * normv4 / gammav + 2 * alphavd ** 2
+        H = np.ones([self.dim, 1]) * 2 - (b + 2 * alphavd ** 2) * vbarbar  # dim x 1
+        invH = H ** (-1)
+        s_step1 = yy - self.normv2 / gammav * (yvbar * ip_yvbar) - np.ones([self.dim, self.popsize + 1])  # dim x popsize+1
+        ip_vbart = self.vbar.T @ t  # 1 x popsize+1
+ 
+        s_step2 = s_step1 - alphavd / gammav * ((2 + self.normv2) * (t * self.vbar) - self.normv2 * vbarbar @ ip_vbart)  # dim x popsize+1
+        invHvbarbar = invH * vbarbar
+        ip_s_step2invHvbarbar = invHvbarbar.T @ s_step2  # 1 x popsize+1
+        
+        div = 1 + b * vbarbar.T @ invHvbarbar
+        if np.amin(abs(div)) == 0:
+            return -1
+        
+        s = (s_step2 * invH) - b / div * invHvbarbar @ ip_s_step2invHvbarbar  # dim x popsize+1
+        ip_svbarbar = vbarbar.T @ s  # 1 x popsize+1
+        t = t - alphavd * ((2 + self.normv2) * (s * self.vbar) - self.vbar @ ip_svbarbar)  # dim x popsize+1
+        # update v, D
+        exw = np.append(self.eta_B(lambF) * weights, np.array([self.c1(lambF)]).reshape(1, 1),
+                        axis=0)  # popsize+1 x 1
+        self.v = self.v + (t @ exw) / self.normv
+        self.D = self.D + (s @ exw) * self.D
+        # calculate detA
+        if np.amin(self.D) < 0:
+            return -1
+
+        nthrootdetA = exp(np.sum(np.log(self.D)) / self.dim + np.log(1 + (self.v.T @ self.v)[0][0]) / (2 * self.dim))
+         
+        self.D = self.D / nthrootdetA
+        
+        # update sigma
+        G_s = np.sum((self.z * self.z - np.ones([self.dim, self.popsize])) @ weights) / self.dim
+        self.sigma = self.sigma * exp(eta_sigma / 2 * G_s)
+        return self.stop
+
+    def population(self) -> np.ndarray:
+        return self.x
+
+    def result(self) -> OptimizeResult:
+        return OptimizeResult(x=self.x_best, fun=self.f_best, nfev=self.no_of_evals, 
+                              nit=self.g, status=self.stop, success=True)
+        
+def exp(a):
+    return math.exp(min(100, a)) # avoid overflow
+
+def get_h_inv(dim):
+    f = lambda a, b: ((1. + a * a) * exp(a * a / 2.) / 0.24) - 10. - dim
+    f_prime = lambda a: (1. / 0.24) * a * exp(a * a / 2.) * (3. + a * a)
+    h_inv = 1.0
+    while abs(f(h_inv, dim)) > 1e-10:
+        h_inv = h_inv - 0.5 * (f(h_inv, dim) / f_prime(h_inv))
+    return h_inv
+
+def sort_indices_by(evals, z):
+    lam = len(evals)
+    evals = np.array(evals)
+    sorted_indices = np.argsort(evals)
+    sorted_evals = evals[sorted_indices]
+    no_of_feasible_solutions = np.where(sorted_evals != INFEASIBLE)[0].size
+    if no_of_feasible_solutions != lam:
+        infeasible_z = z[:, np.where(evals == INFEASIBLE)[0]]
+        distances = np.sum(infeasible_z ** 2, axis=0)
+        infeasible_indices = sorted_indices[no_of_feasible_solutions:]
+        indices_sorted_by_distance = np.argsort(distances)
+        sorted_indices[no_of_feasible_solutions:] = infeasible_indices[indices_sorted_by_distance]
+    return sorted_indices