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

fcmaes/test_cma.py

@@ -3,11 +3,29 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory.
 
-import sys
 import multiprocessing as mp
+import numpy as np
 from scipy.optimize import OptimizeResult
 from fcmaes.testfun import Wrapper, Rosen, Rastrigin, Eggholder
-from fcmaes import cmaes, cmaescpp, retry, advretry
+from fcmaes import cmaes, de, decpp, cmaescpp, retry, advretry
+from fcmaes.optimizer import de_cma_py
+
+def almost_equal(X1, X2, eps = 1E-5):
+    if np.isscalar(X1):
+        X1 = [X1]
+        X2 = [X2]
+    if len(X1) != len(X2):
+        return False
+    for i in range(len(X1)):
+        a = X1[i]
+        b = X2[i]
+        if abs(a) < eps or abs(b) < eps:
+            if abs(a - b) > eps:
+                return False
+        else:
+            if abs(a / b - 1 > eps):
+                return False
+    return True
 
 def test_rastrigin_python():
     popsize = 100
@@ -16,7 +34,7 @@ def test_rastrigin_python():
     sdevs = [1.0]*dim
     max_eval = 100000
 
-    limit = 0.00001   
+    limit = 0.0001   
     # stochastic optimization may fail the first time
     for _ in range(5):
         # use a wrapper to monitor function evaluations
@@ -27,7 +45,7 @@ def test_rastrigin_python():
             break
     
     assert(limit > ret.fun) # optimization target not reached
-    assert(max_eval + popsize > ret.nfev) # too much function calls
+    assert(max_eval + popsize >= ret.nfev) # too much function calls
     assert(max_eval / popsize + 2 > ret.nit) # too much iterations
     assert(ret.status == 4) # wrong cma termination code
     assert(ret.nfev == wrapper.get_count()) # wrong number of function calls returned
@@ -50,24 +68,24 @@ def test_rosen_python():
             break
     
     assert(limit > ret.fun) # optimization target not reached
-    assert(max_eval + popsize > ret.nfev) # too much function calls
+    assert(max_eval + popsize >= ret.nfev) # too much function calls
     assert(max_eval / popsize + 2 > ret.nit) # too much iterations
     assert(ret.nfev == wrapper.get_count()) # wrong number of function calls returned
     assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
     assert(ret.fun == wrapper.get_best_y()) # wrong best y returned
 
 def test_rosen_ask_tell():    
+    popsize = 31
     dim = 5
     testfun = Rosen(dim)
     sdevs = [1.0]*dim
     max_eval = 100000   
     limit = 0.00001 
-    popsize = 31  
     for _ in range(5):
         wrapper = Wrapper(testfun.fun, dim)
         es = cmaes.Cmaes(testfun.bounds,
                 popsize = popsize, input_sigma = sdevs)       
-        iters = 50000 // popsize
+        iters = max_eval // popsize
         for j in range(iters):
             xs = es.ask()
             ys = [wrapper.eval(x) for x in xs]
@@ -80,10 +98,10 @@ def test_rosen_ask_tell():
         if limit > ret.fun:
             break
     assert(limit > ret.fun) # optimization target not reached
-    assert(max_eval + popsize > ret.nfev) # too much function calls
+    assert(max_eval + popsize >= ret.nfev) # too much function calls
     assert(max_eval / popsize + 2 > ret.nit) # too much iterations
-    assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
-    assert(ret.fun == wrapper.get_best_y()) # wrong best y returned
+#     assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
+#     assert(ret.fun == wrapper.get_best_y()) # wrong best y returned
 
 def test_rosen_cpp():
     popsize = 31
@@ -101,7 +119,7 @@ def test_rosen_cpp():
             break
 
     assert(limit > ret.fun) # optimization target not reached
-    assert(max_eval + popsize > ret.nfev) # too much function calls 
+    assert(max_eval + popsize >= ret.nfev) # too much function calls 
     assert(ret.nfev == wrapper.get_count()) # wrong number of function calls returned
     assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
     assert(ret.fun == wrapper.get_best_y()) # wrong best y returned
@@ -118,17 +136,149 @@ def test_rosen_parallel():
         wrapper = Wrapper(testfun.fun, dim)
         ret = cmaes.minimize(wrapper.eval, testfun.bounds, input_sigma = sdevs, 
                        max_evaluations = max_eval, 
-                       popsize=popsize, workers = mp.cpu_count())
+                       popsize=popsize, workers = popsize)
+        if limit > ret.fun:
+            break
+       
+    assert(limit > ret.fun) # optimization target not reached
+    assert(max_eval + popsize >= ret.nfev) # too much function calls
+    assert(max_eval // popsize + 2 > ret.nit) # too much iterations
+    assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
+    assert(almost_equal(ret.fun, wrapper.get_best_y(), eps=1E-1)) # wrong best y returned
+
+def test_rosen_cpp_parallel():
+    popsize = 8
+    dim = 2
+    testfun = Rosen(dim)
+    sdevs = [1.0]*dim
+    max_eval = 10000
+    
+    limit = 0.00001   
+    for _ in range(5):
+        wrapper = Wrapper(testfun.fun, dim)
+        ret = cmaescpp.minimize(wrapper.eval, testfun.bounds, input_sigma = sdevs, 
+                       max_evaluations = max_eval, 
+                       popsize=popsize, workers = popsize)
+        if limit > ret.fun:
+            break
+       
+    assert(limit > ret.fun) # optimization target not reached
+    assert(max_eval + popsize >= ret.nfev) # too much function calls
+    assert(max_eval // popsize + 2 > ret.nit) # too much iterations
+    assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
+    assert(almost_equal(ret.fun, wrapper.get_best_y(), eps = 1E-1)) # wrong best y returned
+
+def test_rosen_de():
+    popsize = 8
+    dim = 2
+    testfun = Rosen(dim)
+    max_eval = 10000    
+    limit = 0.00001   
+    for _ in range(5):
+        wrapper = Wrapper(testfun.fun, dim)
+        ret = de.minimize(wrapper.eval, dim, testfun.bounds,
+                       max_evaluations = max_eval, 
+                       popsize=popsize, workers = None)
         if limit > ret.fun:
             break
        
     assert(limit > ret.fun) # optimization target not reached
-    assert(max_eval + popsize > ret.nfev) # too much function calls
+    assert(max_eval + 2*popsize >= ret.nfev) # too much function calls
     assert(max_eval // popsize + 2 > ret.nit) # too much iterations
     assert(ret.nfev == wrapper.get_count()) # wrong number of function calls returned
     assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
     assert(ret.fun == wrapper.get_best_y()) # wrong best y returned
 
+def test_rosen_de_parallel():
+    popsize = 8
+    dim = 2
+    testfun = Rosen(dim)
+    max_eval = 10000    
+    limit = 0.01   
+    for _ in range(5):
+        wrapper = Wrapper(testfun.fun, dim)
+        ret = de.minimize(wrapper.eval, dim, testfun.bounds,
+                       max_evaluations = max_eval, 
+                       popsize=popsize, workers = popsize)
+        if limit > ret.fun:
+            break
+       
+    assert(limit > ret.fun) # optimization target not reached
+    assert(max_eval + popsize >= ret.nfev) # too much function calls
+    assert(max_eval // popsize + 2 > ret.nit) # too much iterations
+    assert(ret.nfev == wrapper.get_count()) # wrong number of function calls returned
+#     assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
+    assert(almost_equal(ret.fun, wrapper.get_best_y(), eps = 1E-1)) # wrong best y returned
+
+def test_rosen_ask_tell_de():    
+    popsize = 8
+    dim = 2
+    testfun = Rosen(dim)
+    max_eval = 10000  
+    limit = 0.00001 
+    for _ in range(5):
+        wrapper = Wrapper(testfun.fun, dim)
+        es = de.DE(dim, testfun.bounds, popsize = popsize)       
+        iters = max_eval // popsize
+        for j in range(iters):
+            xs = es.ask()
+            ys = [wrapper.eval(x) for x in xs]
+            stop = es.tell(ys, xs)
+            if stop != 0:
+                break 
+        ret = OptimizeResult(x=es.best_x, fun=es.best_value, 
+                             nfev=wrapper.get_count(), 
+                             nit=es.iterations, status=es.stop)
+        if limit > ret.fun:
+            break
+    assert(limit > ret.fun) # optimization target not reached
+    assert(max_eval + 2*popsize >= ret.nfev) # too much function calls
+    assert(max_eval / popsize + 2 > ret.nit) # too much iterations
+#     assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
+    assert(almost_equal(ret.fun, wrapper.get_best_y(), eps = 1E-1)) # wrong best y returned
+
+def test_rosen_decpp():
+    popsize = 8
+    dim = 2
+    testfun = Rosen(dim)
+    max_eval = 10000    
+    limit = 0.00001   
+    for _ in range(5):
+        wrapper = Wrapper(testfun.fun, dim)
+        ret = decpp.minimize(wrapper.eval, dim, testfun.bounds,
+                       max_evaluations = max_eval, 
+                       popsize=popsize, workers = None)
+        if limit > ret.fun:
+            break
+       
+    assert(limit > ret.fun) # optimization target not reached
+    assert(max_eval + 2*popsize >= ret.nfev) # too much function calls
+    assert(max_eval // popsize + 2 > ret.nit) # too much iterations
+    assert(ret.nfev == wrapper.get_count()) # wrong number of function calls returned
+    assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
+    assert(almost_equal(ret.fun, wrapper.get_best_y())) # wrong best y returned
+
+def test_rosen_decpp_parallel():
+    popsize = 8
+    dim = 2
+    testfun = Rosen(dim)
+    max_eval = 10000    
+    limit = 0.01   
+    for _ in range(5):
+        wrapper = Wrapper(testfun.fun, dim)
+        ret = decpp.minimize(wrapper.eval, dim, testfun.bounds,
+                       max_evaluations = max_eval, 
+                       popsize=popsize, workers = popsize)
+        if limit > ret.fun:
+            break
+       
+    assert(limit > ret.fun) # optimization target not reached
+    assert(max_eval + popsize >= ret.nfev) # too much function calls
+    assert(max_eval // popsize + 2 > ret.nit) # too much iterations
+    #assert(ret.nfev == wrapper.get_count()) # wrong number of function calls returned
+    assert(almost_equal(ret.x, wrapper.get_best_x(), eps = 1E-2)) # wrong best X returned
+    assert(almost_equal(ret.fun, wrapper.get_best_y(), eps = 1E-2)) # wrong best y returned
+
 def test_eggholder_python():
     popsize = 1000
     dim = 2
@@ -146,7 +296,7 @@ def test_eggholder_python():
             break
    
     assert(limit > ret.fun) # optimization target not reached
-    assert(max_eval + popsize > ret.nfev) # too much function calls
+    assert(max_eval + popsize >= ret.nfev) # too much function calls
     assert(ret.nfev == wrapper.get_count()) # wrong number of function calls returned
     assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
     assert(ret.fun == wrapper.get_best_y()) # wrong best y returned
@@ -168,15 +318,36 @@ def test_eggholder_retry():
     assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
     assert(ret.fun == wrapper.get_best_y()) # wrong best y returned
 
+from fcmaes.optimizer import de_cma
+
 def test_eggholder_advanced_retry():
     dim = 2
     testfun = Eggholder()
-
+    
     limit = -956   
     for _ in range(5):
         wrapper = Wrapper(testfun.fun, dim)
         ret = advretry.minimize(wrapper.eval, testfun.bounds, 
-                                num_retries=300)
+                                num_retries=96)
+        if limit > ret.fun:
+            break
+        
+    assert(limit > ret.fun) # optimization target not reached
+    assert(ret.nfev == wrapper.get_count()) # wrong number of function calls returned
+    assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
+    assert(almost_equal(ret.fun, wrapper.get_best_y())) # wrong best y returned
+
+def test_eggholder_retry_python():
+    dim = 2
+    testfun = Eggholder()
+    
+    optimizer = de_cma_py(10000)
+    limit = -956   
+    for _ in range(5):
+        wrapper = Wrapper(testfun.fun, dim)
+
+        ret = retry.minimize(wrapper.eval, testfun.bounds, 
+                             num_retries=32, optimizer = optimizer)
         if limit > ret.fun:
             break
 
@@ -184,18 +355,24 @@ def test_eggholder_advanced_retry():
     assert(ret.nfev == wrapper.get_count()) # wrong number of function calls returned
     assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
     assert(ret.fun == wrapper.get_best_y()) # wrong best y returned
+
+def test_eggholder_advanced_retry_python():
+    dim = 2
+    testfun = Eggholder()
+
+    optimizer = de_cma_py(10000)
+    limit = -956   
+    for _ in range(5):
+        wrapper = Wrapper(testfun.fun, dim)
+        ret = advretry.minimize(wrapper.eval, testfun.bounds, 
+                                num_retries=32, optimizer = optimizer)
+        if limit > ret.fun:
+            break
+
+    assert(limit > ret.fun) # optimization target not reached
+    assert(ret.nfev == wrapper.get_count()) # wrong number of function calls returned
+    assert(almost_equal(ret.x, wrapper.get_best_x())) # wrong best X returned
+    assert(almost_equal(ret.fun, wrapper.get_best_y())) # wrong best y returned
+
+#test_rosen_decpp_parallel()
  
-def almost_equal(X1, X2):
-    if len(X1) != len(X2):
-        return False
-    eps = 1E-5
-    for i in range(len(X1)):
-        a = X1[i]
-        b = X2[i]
-        if abs(a) < eps or abs(b) < eps:
-            if abs(a - b) > eps:
-                return False
-        else:
-            if abs(a / b - 1 > eps):
-                return False
-    return True

fcmaes/testfun.py

@@ -26,6 +26,7 @@ class Wrapper(object):
             if y < self.best_y.value:
                 self.best_y.value = y
                 self.best_x[:] = x[:]
+                #print(str(self.count.value) + " " + str(y) + " " + str(x))
             self.count.value += 1
         return y
     
@@ -42,6 +43,21 @@ class Rosen(object):
     
     def __init__(self, dim):    
         _testfun.__init__(self, 'rosen', _rosen, [-5]*dim, [5]*dim)
+
+class Elli(object):
+    
+    def __init__(self, dim):    
+        _testfun.__init__(self, 'elli', _elli, [-5]*dim, [5]*dim)
+
+class Cigar(object):
+    
+    def __init__(self, dim):    
+        _testfun.__init__(self, 'cigar', _cigar, [-5]*dim, [5]*dim)
+
+class Sphere(object):
+    
+    def __init__(self, dim):    
+        _testfun.__init__(self, 'sphere', _sphere, [-5]*dim, [5]*dim)
   
 class Rastrigin(object):
     
@@ -79,6 +95,27 @@ def _rastrigin(x):
     x = np.asarray(x)
     return 10.0*dim + sum(x*x - 10.0*np.cos(2.0*math.pi*x))
 
+def _cigar(x):
+    """cigar test objective function."""
+    factor = 1E6
+    x = np.asarray(x)
+    return x[0]*x[0] + factor * sum(xi*xi for xi in x);
+
+def _sphere(x):
+    """spere test objective function."""
+    x = np.asarray(x)
+    return sum(xi*xi for xi in x);
+
+def _elli(x):
+    """elli test objective function."""
+    dim = len(x)
+    x = np.asarray(x)
+    factor = 1E6
+    f = 0
+    for i in range(dim):
+        f += factor ** (i / (dim - 1.)) * x[i] * x[i]
+    return f
+ 
 def _modify(x, delta):
     dim = len(x)
     modified = np.asarray(x) + delta * np.random.randn(dim)
@@ -97,4 +134,4 @@ def _eggholder(x):
     return (-(x[1] + 47.0)
                         * np.sin(np.sqrt(abs(x[0]/2.0 + (x[1] + 47.0))))
                         - x[0] * np.sin(np.sqrt(abs(x[0] - (x[1] + 47.0))))
-                        )
+                        )

{fcmaes-1.1.3.dist-info → fcmaes-1.6.9.dist-info}/METADATA

@@ -1,37 +1,47 @@
 Metadata-Version: 2.1
 Name: fcmaes
-Version: 1.1.3
+Version: 1.6.9
 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,CMA-ES,Harris hawks,differential evolution,dual annealing,fast CMA,stochastic,gradient free,parallel retry
-Platform: UNKNOWN
+Keywords: optimization,multi-objective,parallel
+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: Intended Audience :: Manufacturing
-Classifier: Intended Audience :: Other Audience
+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: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: scipy
+Requires-Dist: scikit-learn
+Requires-Dist: threadpoolctl
+Requires-Dist: numba
+Requires-Dist: loguru
 
 # 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/Tutorial.adoc)
-- [Results](https://github.com/dietmarwo/fast-cma-es/blob/master/Results.adoc)
-- [PYKEP Gym Results](https://github.com/dietmarwo/fast-cma-es/blob/master/PYKEP.adoc)
-- [Constraints](https://github.com/dietmarwo/fast-cma-es/blob/master/Constraints.adoc)
-- [Expressions](https://github.com/dietmarwo/fast-cma-es/blob/master/Expressions.adoc)
-- [ODE](https://github.com/dietmarwo/fast-cma-es/blob/master/ODE.adoc)
+- [Tutorials](https://github.com/dietmarwo/fast-cma-es/blob/master/tutorials/Tutorials.adoc)
+
+
+
+
 

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.1.3.dist-info → fcmaes-1.6.9.dist-info}/WHEEL

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

fcmaes/hhcpp.py

@@ -1,114 +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 the Harris hawks algorithm.
-    Derived from derived from https://github.com/7ossam81/EvoloPy/blob/master/optimizers/HHO.py.
-    See DOI: https://doi.org/10.1016/j.future.2019.02.028
-"""
-
-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.cmaescpp import callback
-
-os.environ['MKL_DEBUG_CPU_TYPE'] = '5'
-
-def minimize(fun, 
-             dim,
-             bounds = None, 
-             popsize = None, 
-             max_evaluations = 100000, 
-             stop_fittness = None, 
-             rg = Generator(MT19937()),
-             runid=0):   
-
-    """Minimization of a scalar function of one or more variables using a 
-    C++ Harris hawks 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 (n,) 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`, 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.
-    max_evaluations : int, optional
-        Forced termination after ``max_evaluations`` function evaluations.
-    stop_fittness : 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 optimization run. 
-            
-    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 = np.asarray(bounds.lb)
-    upper = np.asarray(bounds.ub)
-    n = dim  
-    if popsize is None:
-        popsize = 31
-    if lower is None:
-        lower = [0]*n
-        upper = [0]*n
-    if stop_fittness is None:
-        stop_fittness = math.inf   
-    array_type = ct.c_double * n   
-    c_callback = call_back_type(callback(fun))
-    seed = int(rg.uniform(0, 2**32 - 1))
-    try:
-        res = optimizeHH_C(runid, c_callback, n, seed,
-                           array_type(*lower), array_type(*upper), 
-                           max_evaluations, stop_fittness,  
-                           popsize)
-        x = np.array(np.fromiter(res, dtype=np.float64, count=n))
-        val = res[n]
-        evals = int(res[n+1])
-        iterations = int(res[n+2])
-        stop = int(res[n+3])
-        freemem(res)
-        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)  
-      
-basepath = os.path.dirname(os.path.abspath(__file__))
-
-if sys.platform.startswith('linux'):
-    libcmalib = ct.cdll.LoadLibrary(basepath + '/lib/libacmalib.so')  
-elif 'mac' in sys.platform:
-    libgtoplib = ct.cdll.LoadLibrary(basepath + '/lib/libacmalib.dylib')  
-else:
-    libcmalib = ct.cdll.LoadLibrary(basepath + '/lib/libacmalib.dll')  
-
-call_back_type = ct.CFUNCTYPE(ct.c_double, ct.c_int, ct.POINTER(ct.c_double))  
-optimizeHH_C = libcmalib.optimizeHH_C
-optimizeHH_C.argtypes = [ct.c_long, call_back_type, ct.c_int, ct.c_int, \
-            ct.POINTER(ct.c_double), ct.POINTER(ct.c_double), \
-            ct.c_int, ct.c_double, ct.c_int]
-
-optimizeHH_C.restype = ct.POINTER(ct.c_double)         
-freemem = libcmalib.free_mem
-freemem.argtypes = [ct.POINTER(ct.c_double)]
-  

fcmaes-1.1.3.dist-info/RECORD

@@ -1,23 +0,0 @@
-fcmaes/__init__.py,sha256=Pm7VOOrhYOC5ZvaBv-0NaZY2_jsL8OkjYMhupBATBrk,351
-fcmaes/advretry.py,sha256=i6lRKPOdFXfm3Fm-dSSKpUo6iiA4e_y7F99TvzdlozE,15964
-fcmaes/astro.py,sha256=WQEYQaVwzuicaj9mljeOI8ym5Xxmg-YoWyK5Ld_G5WA,6547
-fcmaes/cmaes.py,sha256=3K_DYV0B9WPRLFAw2IWHn6E3XQN6h5yQyjFh5JLn-l8,23917
-fcmaes/cmaescpp.py,sha256=ugIS1G2v_wiq-vO7UX1D8yGhVlaGSPVZTWXjMCSf0aI,5948
-fcmaes/dacpp.py,sha256=iSy8cvuZ5n9HEiSeV_kHcuG7g9cXVzfOfQk3gD9-RaQ,4202
-fcmaes/decpp.py,sha256=--XX4FHPkNW_cnSWic4YK7ZuaYMw5HkSHQTyL3hMn8k,5171
-fcmaes/evaluator.py,sha256=Ep_AYoOUZuCBqZjh4cN-_E0eFmDkYWlMHTIMncshZcA,2112
-fcmaes/hhcpp.py,sha256=7sZ7f2qUFD_eayD86r-6BXjepP4pbZ7pstR7Hqv9ccE,4300
-fcmaes/optimizer.py,sha256=WzVOSg_Mq8m37Cd-GdFN8wY5-3ALjHIaOGmwlDT9xhs,14174
-fcmaes/pygmoretry.py,sha256=jhUzod9vut88sAAVuMI4XPpem-C-bp9Mkra16KkzJ1Y,4452
-fcmaes/retry.py,sha256=kBCHdYxRzSKRHZs5aPZUxN4RD_rY_fOyh9JYfyj7lHo,11893
-fcmaes/test_cma.py,sha256=kRC3T8C-m2_Nb2DgcOc12xZ3FMEp8EF7qRKij0vwnj8,7412
-fcmaes/testfun.py,sha256=NP5RmyDWqL3HyStGNasOU9sp-_rzP9sDuJMgVuP_UVE,2982
-fcmaes/lib/libacmalib.dll,sha256=FXKn80Sc7LNdEFjp0gUi6vFow4fNPkAx7EURYMDx-CU,529044
-fcmaes/lib/libacmalib.so,sha256=t8aFmCwspPpBRdFCBK7FyKV7k-gYL7Gkq6ZULvK-7nQ,378656
-fcmaes/lib/libgtoplib.dll,sha256=u41GRA7zld4QZkxNZXdLgcIJ8OczlhNYpkgulRABBrE,153902
-fcmaes/lib/libgtoplib.so,sha256=LqocrBBff-kKjP3BDJF0CA0GISwerkcaKITjqQOib1g,108016
-fcmaes-1.1.3.dist-info/LICENSE,sha256=QB09uUsI-9MeK34mmjlL1YVz0ofHIbuXUP8fBBIDnnI,1072
-fcmaes-1.1.3.dist-info/METADATA,sha256=XL8fHJypHNxJyOSsSgYR1QqFPSeltL5053rXUNjTRzY,1673
-fcmaes-1.1.3.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
-fcmaes-1.1.3.dist-info/top_level.txt,sha256=JXYyWNvUB6Q6XokDpYaJWpQvxEYotJFnFjwFJ37tnbA,7
-fcmaes-1.1.3.dist-info/RECORD,,