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

fcmaes-1.6.9.dist-info/RECORD

@@ -0,0 +1,36 @@
+fcmaes/__init__.py,sha256=nUQ6rXiyzd6oQcfOHbk6uf6hCRXRCHCSuTnzCIsp8s8,507
+fcmaes/advretry.py,sha256=cDTRgdpnmJXW7Ego3Pz5IOy2dJSVBAF5P9yZVZ1E-Zo,18584
+fcmaes/astro.py,sha256=ZQek32Q4u9RqFBYFfsA0gTL1ke_ciXDbfcYjDPagKJI,10603
+fcmaes/bitecpp.py,sha256=Q4omEf38KfFm_gFJAvEX4bVYpCf24ftsThjEH3eG28I,4516
+fcmaes/cmaes.py,sha256=J66REBCH-hQcHL821f9czh31aaZWnX9n0R6pF8vJtlo,26495
+fcmaes/cmaescpp.py,sha256=THJN9sJvkl8VrYb6CIA0B-3CBURsHsRPWLYHV8xRX00,13303
+fcmaes/crfmnes.py,sha256=vgCD0jztApaNs8r7LLgxoWuOF7Gmz8SR8kJpW2H_JR0,15105
+fcmaes/crfmnescpp.py,sha256=aU7z-JV_2oKmfRxWuwmiosFnjXaTyFoyj0PZa9lniLc,10928
+fcmaes/dacpp.py,sha256=By1pJ_ZXbOHlNP8uwkgu7dkz4ci00JiK_gYU84HVC1c,3927
+fcmaes/de.py,sha256=zJkhGAFnl25r4Ac1PCC185PiF3o1RoQCGL7cIpKTl78,19829
+fcmaes/decpp.py,sha256=JYkhBydeHUzqM5rGffR7BOKj1uM2bu5J1UZfsU4uxms,12498
+fcmaes/diversifier.py,sha256=K3UlP-eSCiSXkhNVLIxPSrDD4iN540NQNexIU5J97w4,16511
+fcmaes/evaluator.py,sha256=2MGjDKgEl81sheCNfUD5dBMtGkZCb2ao-2898A-Vn1o,11547
+fcmaes/mapelites.py,sha256=sFZJ6jYTBwpOUmKrXgRY78fuCxDvhlyYQyOp_uuCd4w,29624
+fcmaes/mode.py,sha256=9A06iR3ELS0JmYxYKhyNvMLdY9D0W_63fMHj7qjRUi8,29538
+fcmaes/modecpp.py,sha256=IL_shkzSFmB4lYMNeh361sVEPvIa-JLfEdaU5dO4QJE,20876
+fcmaes/moretry.py,sha256=9f1i23wqLxGmYFuKYXyeQvhyw5KGoPG3NVVID22ZRYg,11037
+fcmaes/multiretry.py,sha256=s9AfogJYeJ-HOjkueBq25zXx3AKZ12WuwOGm0mY8Xuw,7047
+fcmaes/optimizer.py,sha256=zfo8u6Y_JkVO64NyedKDOqInhOWTvlaVzIoO6z6f9LM,46215
+fcmaes/pgpecpp.py,sha256=HEeL2WkV6ZuckXm_znwGB9zCdcKelS7qg5mYNOFA7rw,14444
+fcmaes/pygmoretry.py,sha256=dT_EktuUiiNwubqqv-BDUbCNx0xlfF-10LztsAMOB68,4044
+fcmaes/retry.py,sha256=_bpF8_haBNGsVQjWcpvV5L3a0cqQ7sgcuxVTUAPJCdo,17586
+fcmaes/test_cma.py,sha256=PsOP2Mw18KEnT3oUJ1FnAHRP_SM4MO5CbBYrvrCdbDk,14332
+fcmaes/testfun.py,sha256=3T14avHA9sRMuVF2Ua-s9JyXJl1lsvkyyASIYudXBSk,3924
+fcmaes/lib/libacmalib.dll,sha256=NX56nxX3zeYNxAKUTr8_DHIS7uR1lwmiYKpvaXs7vgE,3804965
+fcmaes/lib/libacmalib.dylib,sha256=6G6ttXLNkqKpZDNlijZvplJwGGHRfKBKyesefAIL-qk,1004744
+fcmaes/lib/libacmalib.so,sha256=WZPX4ZNRVJm8RqzuuoTdGh1v7SwqfrGBOKRmLxYWiKM,2750968
+fcmaes/lib/libhbv.so,sha256=TFhps8YXUHUxenkIP6-rO8Cassx4ZUHKhLXR0byTViI,60504
+fcmaes/lib/liblrgv.so,sha256=NAEEgJA3R6-8SQbbmykSexe5-2a1t9X3-aIKf79crvs,190912
+fcmaes/lib/librw_top_trumps.dll,sha256=q-tamxFTwv3X_ByXnFw0SS_CRgAh59xBBJbsp_IXpj8,214992
+fcmaes/lib/librw_top_trumps.so,sha256=gPgydLnAu6UD34znWtRw33mAd_TWcSea1MwUxpahX0Y,129920
+fcmaes-1.6.9.dist-info/LICENSE,sha256=QB09uUsI-9MeK34mmjlL1YVz0ofHIbuXUP8fBBIDnnI,1072
+fcmaes-1.6.9.dist-info/METADATA,sha256=LCzNkQ7asm6bY-OOaCf1wa8ceNPQYIit_RZpxI-UPZM,1693
+fcmaes-1.6.9.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+fcmaes-1.6.9.dist-info/top_level.txt,sha256=JXYyWNvUB6Q6XokDpYaJWpQvxEYotJFnFjwFJ37tnbA,7
+fcmaes-1.6.9.dist-info/RECORD,,

{fcmaes-1.3.17.dist-info → fcmaes-1.6.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: setuptools (75.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

fcmaes/csmacpp.py

@@ -1,108 +0,0 @@
-# Copyright (c) Dietmar Wolz.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory.
-
-""" Implements a Sigma Adaptation Evolution Strategy 
-    similar to CMA-ES, but mainly focuses on sigma adaptation.
-    Description is available at https://github.com/avaneev/biteopt
-"""
-
-import sys
-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
-
-os.environ['MKL_DEBUG_CPU_TYPE'] = '5'
-
-def minimize(fun, 
-             bounds=None, 
-             x0=None, 
-             input_sigma = 0.166, 
-             popsize = 0, 
-             max_evaluations = 100000, 
-             stop_fitness = None, 
-             rg = Generator(MT19937()),
-             runid=0):
-       
-    """Minimization of a scalar function of one or more variables using a 
-    C++ SCMA implementation called via ctypes.
-     
-    Parameters
-    ----------
-    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.
-    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.
-    stop_fitness : float, optional 
-         Limit for fitness value. If reached minimize terminates.
-    rg = numpy.random.Generator, optional
-        Random generator for creating random guesses.
-    runid : int, optional
-        id used to identify the run for debugging / logging. 
-           
-    Returns
-    -------
-    res : scipy.OptimizeResult
-        The optimization result is represented as an ``OptimizeResult`` object.
-        Important attributes are: ``x`` the solution array, 
-        ``fun`` the best function value, 
-        ``nfev`` the number of function evaluations,
-        ``nit`` the number of CMA-ES iterations, 
-        ``status`` the stopping critera and
-        ``success`` a Boolean flag indicating if the optimizer exited successfully. """
-    
-    lower, upper, guess = _check_bounds(bounds, x0, rg)      
-    dim = guess.size   
-    if lower is None:
-        lower = [0]*dim
-        upper = [0]*dim
-    if callable(input_sigma):
-        input_sigma=input_sigma()
-    if np.ndim(input_sigma) == 0:
-        input_sigma = [input_sigma] * dim
-    if stop_fitness is None:
-        stop_fitness = -math.inf   
-    array_type = ct.c_double * dim 
-    c_callback = mo_call_back_type(callback(fun, dim))
-    res = np.empty(dim+4)
-    res_p = res.ctypes.data_as(ct.POINTER(ct.c_double))
-    try:
-        optimizeCsma_C(runid, c_callback, dim, int(rg.uniform(0, 2**32 - 1)), 
-                array_type(*guess), array_type(*lower), array_type(*upper), 
-                array_type(*input_sigma), max_evaluations, stop_fitness, popsize, 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)
-    except Exception as ex:
-        return OptimizeResult(x=None, fun=sys.float_info.max, nfev=0, nit=0, status=-1, success=False)
-
-optimizeCsma_C = libcmalib.optimizeCsma_C
-optimizeCsma_C.argtypes = [ct.c_long, mo_call_back_type, ct.c_int, 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.POINTER(ct.c_double)]
-        

fcmaes/gcldecpp.py

@@ -1,148 +0,0 @@
-# Copyright (c) Mingcheng Zuo, Dietmar Wolz.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory.
-
-"""Eigen based implementation of differential evolution (GCL-DE) derived from
-    "A case learning-based differential evolution algorithm for global optimization of interplanetary trajectory design,
-    Mingcheng Zuo, Guangming Dai, Lei Peng, Maocai Wang, Zhengquan Liu", https://doi.org/10.1016/j.asoc.2020.106451
-"""
-
-import sys
-import os
-import math
-import ctypes as ct
-import numpy as np
-import multiprocessing as mp
-from numpy.random import MT19937, Generator
-from scipy.optimize import OptimizeResult
-from fcmaes.ldecpp import callback_par, call_back_par
-from fcmaes.decpp import libcmalib
-from fcmaes import de
-from fcmaes.evaluator import Evaluator, eval_parallel
-
-os.environ['MKL_DEBUG_CPU_TYPE'] = '5'
-
-def minimize(fun, 
-             dim = None,
-             bounds = None, 
-             popsize = None, 
-             max_evaluations = 100000, 
-             stop_fitness = None, 
-             pbest = 0.7,
-             f0 = 0.0,
-             cr0 = 0.0,
-             rg = Generator(MT19937()),
-             runid=0,
-             workers = None):  
-     
-    """Minimization of a scalar function of one or more variables using a 
-    C++ GCL Differential Evolution implementation called via ctypes.
-     
-    Parameters
-    ----------
-    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.
-    dim : int
-        dimension of the argument of the objective function
-    bounds : sequence or `Bounds`
-        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`.
-    popsize : int, optional
-        Population size.
-    max_evaluations : int, optional
-        Forced termination after ``max_evaluations`` function evaluations.
-    stop_fitness : float, optional 
-         Limit for fitness value. If reached minimize terminates.
-    pbest = float, optional
-        use low value 0 < pbest <= 1 to narrow search.
-    f0 = float, optional
-        The initial mutation constant. In the literature this is also known as differential weight, 
-        being denoted by F. Should be in the range [0, 2].
-    cr0 = float, optional
-        The initial recombination constant. Should be in the range [0, 1]. 
-        In the literature this is also known as the crossover probability.     
-    rg = numpy.random.Generator, optional
-        Random generator for creating random guesses.
-    runid : int, optional
-        id used to identify the run for debugging / logging. 
-    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.      
- 
-           
-    Returns
-    -------
-    res : scipy.OptimizeResult
-        The optimization result is represented as an ``OptimizeResult`` object.
-        Important attributes are: ``x`` the solution array, 
-        ``fun`` the best function value, 
-        ``nfev`` the number of function evaluations,
-        ``nit`` the number of iterations,
-        ``success`` a Boolean flag indicating if the optimizer exited successfully. """
-                
-    dim, lower, upper = de._check_bounds(bounds, dim)
-    if popsize is None:
-        popsize = int(dim*8.5+150)
-    if lower is None:
-        lower = [0]*dim
-        upper = [0]*dim
-    if stop_fitness is None:
-        stop_fitness = math.inf   
-    parfun = None if workers is None else parallel(fun, workers)
-    array_type = ct.c_double * dim   
-    c_callback_par = call_back_par(callback_par(fun, parfun))
-    seed = int(rg.uniform(0, 2**32 - 1))
-    res = np.empty(dim+4)
-    res_p = res.ctypes.data_as(ct.POINTER(ct.c_double))
-    try:
-        optimizeGCLDE_C(runid, c_callback_par, dim, seed,
-                           array_type(*lower), array_type(*upper), 
-                           max_evaluations, pbest, stop_fitness,  
-                           popsize, f0, cr0, res_p)
-        x = res[:dim]
-        val = res[dim]
-        evals = int(res[dim+1])
-        iterations = int(res[dim+2])
-        stop = int(res[dim+3])
-        if not parfun is None:
-            parfun.stop() # stop all parallel evaluation processes
-        return OptimizeResult(x=x, fun=val, nfev=evals, nit=iterations, status=stop, success=True)
-    except Exception as ex:
-        if not workers is None:
-            fun.stop() # stop all parallel evaluation processes
-        return OptimizeResult(x=None, fun=sys.float_info.max, nfev=0, nit=0, status=-1, success=False)  
-
-class parallel(object):
-    """Convert an objective function for parallel execution for cmaes.minimize.
-    
-    Parameters
-    ----------
-    fun : objective function mapping a list of float arguments to a float value.
-   
-    represents a function mapping a list of lists of float arguments to a list of float values
-    by applying the input function using parallel processes. stop needs to be called to avoid
-    a resource leak"""
-        
-    def __init__(self, fun, workers = mp.cpu_count()):
-        self.evaluator = Evaluator(fun)
-        self.evaluator.start(workers)
-    
-    def __call__(self, xs):
-        return eval_parallel(xs, self.evaluator)
-
-    def stop(self):
-        self.evaluator.stop()
-      
-optimizeGCLDE_C = libcmalib.optimizeGCLDE_C
-optimizeGCLDE_C.argtypes = [ct.c_long, call_back_par, ct.c_int, ct.c_int, \
-            ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), \
-            ct.c_int, ct.c_double, ct.c_double, ct.c_int, \
-            ct.c_double, ct.c_double, ct.POINTER(ct.c_double)]
-         
-

fcmaes/lcldecpp.py

@@ -1,138 +0,0 @@
-# Copyright (c) Mingcheng Zuo, Dietmar Wolz.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory.
-
-"""Eigen based implementation of differential evolution (LCL-DE) derived from
-    "A case learning-based differential evolution algorithm for global optimization of interplanetary trajectory design,
-    Mingcheng Zuo, Guangming Dai, Lei Peng, Maocai Wang, Zhengquan Liu", https://doi.org/10.1016/j.asoc.2020.106451
-    To be used to further optimize a given solution. Initial population is created using a normal distribition 
-    with mean=x0 and sdev = input_sigma (normalized over the bounds and can be defined separately for each variable)
-"""
-
-import sys
-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.ldecpp import callback_par, call_back_par
-from fcmaes.decpp import libcmalib
-from fcmaes.cmaes import _check_bounds
-from fcmaes.gcldecpp import parallel
-
-os.environ['MKL_DEBUG_CPU_TYPE'] = '5'
-
-def minimize(fun, 
-             bounds=None, 
-             x0=None, 
-             input_sigma = 0.3, 
-             popsize = None, 
-             max_evaluations = 100000, 
-             stop_fitness = None, 
-             pbest = 0.7,
-             f0 = 0.0,
-             cr0 = 0.0,
-             rg = Generator(MT19937()),
-             runid=0,
-             workers = None):  
-     
-    """Minimization of a scalar function of one or more variables using a 
-    C++ LCL Differential Evolution implementation called via ctypes.
-     
-    Parameters
-    ----------
-    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.
-    bounds : sequence or `Bounds`
-        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`.
-    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
-        Population size.
-    max_evaluations : int, optional
-        Forced termination after ``max_evaluations`` function evaluations.
-    stop_fitness : float, optional 
-         Limit for fitness value. If reached minimize terminates.
-    pbest = float, optional
-        use low value 0 < pbest <= 1 to narrow search.
-    f0 = float, optional
-        The initial mutation constant. In the literature this is also known as differential weight, 
-        being denoted by F. Should be in the range [0, 2].
-    cr0 = float, optional
-        The initial recombination constant. Should be in the range [0, 1]. 
-        In the literature this is also known as the crossover probability.     
-    rg = numpy.random.Generator, optional
-        Random generator for creating random guesses.
-    runid : int, optional
-        id used to identify the run for debugging / logging. 
-    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.      
- 
-           
-    Returns
-    -------
-    res : scipy.OptimizeResult
-        The optimization result is represented as an ``OptimizeResult`` object.
-        Important attributes are: ``x`` the solution array, 
-        ``fun`` the best function value, 
-        ``nfev`` the number of function evaluations,
-        ``nit`` the number of iterations,
-        ``success`` a Boolean flag indicating if the optimizer exited successfully. """
-
-    lower, upper, guess = _check_bounds(bounds, x0, rg)      
-    dim = guess.size  
-    if popsize is None:
-        popsize = int(dim*8.5+150)
-    if lower is None:
-        lower = [0]*dim
-        upper = [0]*dim
-    if callable(input_sigma):
-        input_sigma=input_sigma()
-    if np.ndim(input_sigma) == 0:
-        input_sigma = [input_sigma] * dim
-    if stop_fitness is None:
-        stop_fitness = math.inf   
-    parfun = None if workers is None else parallel(fun, workers)
-    array_type = ct.c_double * dim   
-    c_callback_par = call_back_par(callback_par(fun, parfun))
-    seed = int(rg.uniform(0, 2**32 - 1))
-    res = np.empty(dim+4)
-    res_p = res.ctypes.data_as(ct.POINTER(ct.c_double))
-    try:
-        optimizeLCLDE_C(runid, c_callback_par, dim, 
-                           array_type(*guess), array_type(*input_sigma), seed,
-                           array_type(*lower), array_type(*upper), 
-                           max_evaluations, pbest, stop_fitness,  
-                           popsize, f0, cr0, res_p)
-        x = res[:dim]
-        val = res[dim]
-        evals = int(res[dim+1])
-        iterations = int(res[dim+2])
-        stop = int(res[dim+3])
-        if not parfun is None:
-            parfun.stop() # stop all parallel evaluation processes
-        return OptimizeResult(x=x, fun=val, nfev=evals, nit=iterations, status=stop, success=True)
-    except Exception as ex:
-        if not workers is None:
-            fun.stop() # stop all parallel evaluation processes
-        return OptimizeResult(x=None, fun=sys.float_info.max, nfev=0, nit=0, status=-1, success=False)  
-      
-optimizeLCLDE_C = libcmalib.optimizeLCLDE_C
-optimizeLCLDE_C.argtypes = [ct.c_long, call_back_par, ct.c_int, 
-            ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), ct.c_int, \
-            ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), \
-            ct.c_int, ct.c_double, ct.c_double, ct.c_int, \
-            ct.c_double, ct.c_double, ct.POINTER(ct.c_double)]
-       

fcmaes/ldecpp.py

@@ -1,172 +0,0 @@
-# Copyright (c) Dietmar Wolz.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory.
-
-"""Eigen based implementation of differential evolution using onl the DE/best/1 strategy.
-    Uses two deviations from the standard DE algorithm:
-    a) temporal locality introduced in 
-        https://www.researchgate.net/publication/309179699_Differential_evolution_for_protein_folding_optimization_based_on_a_three-dimensional_AB_off-lattice_model
-    b) reinitialization of individuals based on their age.
-    To be used to further optimize a given solution. Initial population is created using a normal distribition 
-    with mean=x0 and sdev = input_sigma (normalized over the bounds and can be defined separately for each variable)
-    """
-
-import sys
-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.decpp import libcmalib
-from fcmaes.cmaes import _check_bounds
-
-os.environ['MKL_DEBUG_CPU_TYPE'] = '5'
-
-def minimize(fun, 
-             bounds=None, 
-             x0=None, 
-             input_sigma = 0.3, 
-             popsize = None, 
-             max_evaluations = 100000, 
-             stop_fitness = None, 
-             keep = 200,
-             f = 0.5,
-             cr = 0.9,
-             rg = Generator(MT19937()),
-             runid=0):  
-     
-    """Minimization of a scalar function of one or more variables using a 
-    C++ Differential Evolution implementation called via ctypes.
-     
-    Parameters
-    ----------
-    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.
-    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
-        Population size.
-    max_evaluations : int, optional
-        Forced termination after ``max_evaluations`` function evaluations.
-    stop_fitness : float, optional 
-         Limit for fitness value. If reached minimize terminates.
-    keep = float, optional
-        changes the reinitialization probability of individuals based on their age. Higher value
-        means lower probablity of reinitialization.
-    f = float, optional
-        The mutation constant. In the literature this is also known as differential weight, 
-        being denoted by F. Should be in the range [0, 2].
-    cr = float, optional
-        The recombination constant. Should be in the range [0, 1]. 
-        In the literature this is also known as the crossover probability.     
-    rg = numpy.random.Generator, optional
-        Random generator for creating random guesses.
-    runid : int, optional
-        id used to identify the run for debugging / logging. 
-            
-    Returns
-    -------
-    res : scipy.OptimizeResult
-        The optimization result is represented as an ``OptimizeResult`` object.
-        Important attributes are: ``x`` the solution array, 
-        ``fun`` the best function value, 
-        ``nfev`` the number of function evaluations,
-        ``nit`` the number of iterations,
-        ``success`` a Boolean flag indicating if the optimizer exited successfully. """
-
-    lower, upper, guess = _check_bounds(bounds, x0, rg)      
-    dim = guess.size  
-    if popsize is None:
-        popsize = 31
-    if lower is None:
-        lower = [0]*dim
-        upper = [0]*dim
-    if callable(input_sigma):
-        input_sigma=input_sigma()
-    if np.ndim(input_sigma) == 0:
-        input_sigma = [input_sigma] * dim
-    if stop_fitness is None:
-        stop_fitness = math.inf   
-    array_type = ct.c_double * dim   
-    c_callback = call_back_type(callback(fun))
-    seed = int(rg.uniform(0, 2**32 - 1))
-    res = np.empty(dim+4)
-    res_p = res.ctypes.data_as(ct.POINTER(ct.c_double))
-    try:
-        optimizeLDE_C(runid, c_callback, dim, 
-                           array_type(*guess), array_type(*input_sigma), seed,
-                           array_type(*lower), array_type(*upper), 
-                           max_evaluations, keep, stop_fitness,  
-                           popsize, f, cr, 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)
-    except Exception as ex:
-        return OptimizeResult(x=None, fun=sys.float_info.max, nfev=0, nit=0, status=-1, success=False)  
-
-class callback(object):
-    
-    def __init__(self, fun):
-        self.fun = fun
-    
-    def __call__(self, n, x):
-        try:
-            fit = self.fun([x[i] for i in range(n)])
-            return fit if math.isfinite(fit) else sys.float_info.max
-        except Exception as ex:
-            return sys.float_info.max
-
-class callback_par(object):
-    
-    def __init__(self, fun, parfun):
-        self.fun = fun
-        self.parfun = parfun
-    
-    def __call__(self, popsize, n, xs_, ys_):
-        try:
-            arrType = ct.c_double*(popsize*n)
-            addr = ct.addressof(xs_.contents)
-            xall = np.frombuffer(arrType.from_address(addr))
-            
-            if self.parfun is None:
-                for p in range(popsize):
-                    ys_[p] = self.fun(xall[p*n : (p+1)*n])
-            else:    
-                xs = []
-                for p in range(popsize):
-                    x = xall[p*n : (p+1)*n]
-                    xs.append(x)
-                ys = self.parfun(xs)
-                for p in range(popsize):
-                    ys_[p] = ys[p]
-        except Exception as ex:
-            print (ex)
-
-call_back_type = ct.CFUNCTYPE(ct.c_double, ct.c_int, ct.POINTER(ct.c_double))  
-call_back_par = ct.CFUNCTYPE(None, ct.c_int, ct.c_int, \
-                                  ct.POINTER(ct.c_double), ct.POINTER(ct.c_double))  
-      
-optimizeLDE_C = libcmalib.optimizeLDE_C
-optimizeLDE_C.argtypes = [ct.c_long, call_back_type, ct.c_int, 
-            ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), ct.c_int, \
-            ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), \
-            ct.c_int, ct.c_double, ct.c_double, ct.c_int, \
-            ct.c_double, ct.c_double, ct.POINTER(ct.c_double)]
-     

fcmaes-1.3.17.dist-info/METADATA

@@ -1,55 +0,0 @@
-Metadata-Version: 2.1
-Name: fcmaes
-Version: 1.3.17
-Summary: A Python 3 gradient-free optimization library.
-Home-page: https://github.com/dietmarwo/fast-cma-es
-Author: Dietmar Wolz
-Author-email: drdietmarwolz@yahoo.de
-License: MIT
-Keywords: optimization,multi-objective,constraints,CMA-ES,BiteOpt,MO-DE,differential evolution,annealing,stochastic,gradient free,parallel execution,boundary management
-Platform: UNKNOWN
-Classifier: Intended Audience :: Manufacturing
-Classifier: Intended Audience :: Financial and Insurance Industry
-Classifier: Intended Audience :: Healthcare Industry
-Classifier: Intended Audience :: Telecommunications Industry
-Classifier: Intended Audience :: Information Technology
-Classifier: Intended Audience :: Science/Research
-Classifier: Intended Audience :: Education
-Classifier: Topic :: Office/Business :: Financial
-Classifier: Topic :: Office/Business :: Scheduling
-Classifier: Topic :: Scientific/Engineering
-Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Classifier: Topic :: Scientific/Engineering :: Mathematics
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Console
-Classifier: License :: OSI Approved :: MIT License
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: scipy
-
-# fcmaes
-A Python 3 gradient-free optimization library.
-
-- [README](https://github.com/dietmarwo/fast-cma-es/blob/master/README.adoc)
-- [Tutorial](https://github.com/dietmarwo/fast-cma-es/blob/master/tutorials/Tutorial.adoc)
-- [Multi-Objective](https://github.com/dietmarwo/fast-cma-es/blob/master/tutorials/MultiObjective.adoc), 
-- [MO-DE-NSGAII](https://github.com/dietmarwo/fast-cma-es/blob/master/tutorials/NSGAII.adoc), 
-- [gbea TopTrumps Benchmark](https://github.com/dietmarwo/fast-cma-es/blob/master/tutorials/TopTrumps.adoc),
-- [Pagmo results](https://github.com/dietmarwo/fast-cma-es/blob/master/tutorials/PAGMO.adoc), 
-- [PYKEP Gym Results](https://github.com/dietmarwo/fast-cma-es/blob/master/tutorials/PYKEP.adoc)
-- [Constraints](https://github.com/dietmarwo/fast-cma-es/blob/master/tutorials/Constraints.adoc)
-- [Expressions](https://github.com/dietmarwo/fast-cma-es/blob/master/tutorials/Expressions.adoc)
-- [ODE](https://github.com/dietmarwo/fast-cma-es/blob/master/tutorials/ODE.adoc)
-- [MINLP](https://github.com/dietmarwo/fast-cma-es/blob/master/tutorials/MINLP.adoc)
-- [HyperParameters](https://github.com/dietmarwo/fast-cma-es/blob/master/tutorials/HyperparameterOptimization.adoc)
-- [Delayed Update](https://github.com/dietmarwo/fast-cma-es/blob/master/tutorials/DelayedUpdate.adoc)
-
-
-
-
-
-