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

fcmaes/astro.py

@@ -6,38 +6,37 @@
 import sys
 import math
 import os
-import numpy as np
 import ctypes as ct
 from scipy.optimize import Bounds
+from fcmaes.decpp import libcmalib
 
-basepath = os.path.dirname(os.path.abspath(__file__))
-if sys.platform.startswith('linux'):
-    libgtoplib = ct.cdll.LoadLibrary(basepath + '/lib/libgtoplib.so')    
-elif 'mac' in sys.platform:
-    libgtoplib = ct.cdll.LoadLibrary(basepath + '/lib/libgtoplib.dylib')  
-else:
-    libgtoplib = ct.cdll.LoadLibrary(basepath + '/lib/libgtoplib.dll')
+if not libcmalib is None: 
+    
+    astro_map = {  
+        "messengerfullC": libcmalib.messengerfullC,
+        "messengerC": libcmalib.messengerC,
+        "gtoc1C": libcmalib.gtoc1C,
+        "cassini1C": libcmalib.cassini1C,
+        "cassini1minlpC": libcmalib.cassini1minlpC,
+        "cassini2C": libcmalib.cassini2C,
+        "rosettaC": libcmalib.rosettaC,
+        "sagasC": libcmalib.sagasC,
+        "tandemC": libcmalib.tandemC,
+        "tandemCu": libcmalib.tandemCu,
+        "cassini2minlpC": libcmalib.cassini2minlpC,
+    }
 
+    freemem = libcmalib.free_mem
+    freemem.argtypes = [ct.POINTER(ct.c_double)]    
+    
 class Astrofun(object):
     """Provides access to ESAs GTOP optimization test functions."""
     def __init__(self, name, fun_c, lower, upper):    
         self.name = name 
+        self.fun_c = fun_c 
         self.bounds = Bounds(lower, upper)
         self.fun = python_fun(fun_c, self.bounds)
 
-# for windows compatibility. Linux can pickle c pointers, windows can not
-astro_map = {  
-    "messengerfullC": libgtoplib.messengerfullC,
-    "messengerC": libgtoplib.messengerC,
-    "gtoc1C": libgtoplib.gtoc1C,
-    "cassini1C": libgtoplib.cassini1C,
-    "cassini2C": libgtoplib.cassini2C,
-    "rosettaC": libgtoplib.rosettaC,
-    "sagasC": libgtoplib.sagasC,
-    "tandemC": libgtoplib.tandemC,
-    "tandemCu": libgtoplib.tandemCu
-    }
-
 for func in astro_map:
     astro_map[func].argtypes = [ct.c_int, ct.POINTER(ct.c_double)]           
     astro_map[func].restype = ct.c_double           
@@ -66,7 +65,12 @@ class Gtoc1(object):
         Astrofun.__init__(self, 'GTOC1', "gtoc1C", 
                            [3000.,14.,14.,14.,14.,100.,366.,300.],
                            [10000.,2000.,2000.,2000.,2000.,9000.,9000.,9000.]       
-       )
+                           )
+        self.gfun = self.fun
+        self.fun = self.gtoc1       
+    
+    def gtoc1(self, x):
+        return self.gfun(x) - 2000000
 
 class Cassini1(object):
     """ see https://www.esa.int/gsp/ACT/projects/gtop/cassini1/ """
@@ -108,7 +112,7 @@ class Tandem(object):
     """ see https://www.esa.int/gsp/ACT/projects/gtop/tandem/ """
     def __init__(self, i, constrained=True):   
         self.name = ('Tandem ' if constrained else 'Tandem unconstrained ') + str(i+1)
-        self.cfun = "tandemC" if constrained else "tandemCu"
+        self.fun_c = "tandemC" if constrained else "tandemCu"
         self.fun = self.tandem
         self.bounds = Bounds([5475, 2.5, 0, 0, 20, 20, 20, 20, 0.01, 0.01, 0.01, 0.01, 1.05, 1.05, 1.05, -math.pi, -math.pi, -math.pi], 
                              [9132, 4.9, 1, 1, 2500, 2500, 2500, 2500, 0.99, 0.99, 0.99, 0.99, 10, 10, 10, math.pi,  math.pi,  math.pi])
@@ -123,17 +127,128 @@ class Tandem(object):
         n = len(x)
         array_type = ct.c_double * n   
         ints_type = ct.c_int * 5   
-        fun_c = astro_map[self.cfun]      
+        fun_c = astro_map[self.fun_c]      
         fun_c.argtypes = [ct.c_int, ct.POINTER(ct.c_double), ct.POINTER(ct.c_int)]
         try: # function is only defined inside bounds
-            x = np.asarray(x).clip(self.bounds.lb, self.bounds.ub)
+            #x = np.asarray(x).clip(self.bounds.lb, self.bounds.ub)
             val = fun_c(n, array_type(*x), ints_type(*self.seq))
             if not math.isfinite(val):
                 val = 1E10
         except Exception as ex:
             val = 1E10
         return val
-  
+
+class Tandem_minlp(object):
+    """ see https://www.esa.int/gsp/ACT/projects/gtop/tandem/ """
+    def __init__(self, constrained=True):   
+        self.name = ('Tandem minlp ' if constrained else 'Tandem unconstrained minlp ') 
+        self.fun_c = "tandemC" if constrained else "tandemCu"
+        self.fun = self.tandem_minlp
+        self.bounds = Bounds([5475, 2.5, 0, 0, 20, 20, 20, 20, 0.01, 0.01, 0.01, 0.01, 1.05, 1.05, 1.05, -math.pi, -math.pi, -math.pi,
+                              1.51,1.51,1.51], 
+                             [9132, 4.9, 1, 1, 2500, 2500, 2500, 2500, 0.99, 0.99, 0.99, 0.99, 10, 10, 10, math.pi,  math.pi,  math.pi,
+                              3.49,4.49,5.49])
+         
+    def tandem_minlp(self, xs):
+        n = len(xs) - 3
+        x = xs[:-3]
+        seq = [3] + [int(round(xi)) for xi in xs[-3:]] + [6]
+        array_type = ct.c_double * n   
+        ints_type = ct.c_int * 5   
+        fun_c = astro_map[self.fun_c]      
+        fun_c.argtypes = [ct.c_int, ct.POINTER(ct.c_double), ct.POINTER(ct.c_int)]
+        try:
+            val = fun_c(n, array_type(*x), ints_type(*seq))
+            if not math.isfinite(val):
+                val = 1E10
+        except Exception as ex:
+            val = 1E10
+        return val
+
+class Cassini1multi(object):
+    """ see https://www.esa.int/gsp/ACT/projects/gtop/cassini1/ """
+    
+    def __init__(self, weights = [1,0,0,0], planets = [2,2,3,5]):    
+        Astrofun.__init__(self, 'Cassini1minlp', "Cassini1minlpC", 
+                           [-1000.,30.,100.,30.,400.,1000.],
+                           [0.,400.,470.,400.,2000.,6000.]       
+        )
+        self.fun = self.cassini1
+        self.weights = weights
+        self.planets = planets
+        self.mfun = lambda x: cassini1multi(x + [2,2,3,5])
+         
+    def cassini1(self, x):
+        r = cassini1multi(x + self.planets)
+        return self.weights[0]*r[0] + self.weights[1]*r[1] + self.weights[2]*r[2] + self.weights[3]*r[3]
+    
+class Cassini1minlp(object):
+    """ see https://www.esa.int/gsp/ACT/projects/gtop/cassini1/ """
+    
+    def __init__(self, planets = [2,2,3,5]):    
+        Astrofun.__init__(self, 'Cassini1', "cassini1C", 
+                           [-1000.,30.,100.,30.,400.,1000.],
+                           [0.,400.,470.,400.,2000.,6000.]       
+        )
+        self.fun = self.cassini1
+        self.planets = planets
+   
+    def cassini1(self, x):
+        return cassini1minlp(list(x) + self.planets)
+      
+def cassini1minlp(x):
+    n = len(x)
+    array_type = ct.c_double * n   
+    fun_c = astro_map["cassini1minlpC"]      
+    fun_c.argtypes = [ct.c_int, ct.POINTER(ct.c_double)]
+    fun_c.restype = ct.POINTER(ct.c_double)  
+    try: # function is only defined inside bounds
+        res = fun_c(n, array_type(*x))
+        dv = res[0]
+        freemem(res)
+        if not math.isfinite(dv):
+            dv = 1E10
+    except Exception as ex:
+        print(ex)
+        dv = 1E10
+    return dv
+
+def cassini1multi(x):
+    n = len(x)
+    array_type = ct.c_double * n   
+    fun_c = astro_map["cassini1minlpC"]      
+    fun_c.argtypes = [ct.c_int, ct.POINTER(ct.c_double)]
+    fun_c.restype = ct.POINTER(ct.c_double)  
+    try: # function is only defined inside bounds
+        res = fun_c(n, array_type(*x))
+        dv = res[0]
+        launch_dv = res[1]
+        freemem(res)
+        if not math.isfinite(dv):
+            dv = 1E10
+    except Exception as ex:
+        print(ex)
+        dv = 1E10
+        launch_dv = 1E10 
+    tof = sum(x[1:6])
+    launch_time = x[0] 
+    return [dv, tof, launch_time]
+
+def cassini2multi(x):
+    n = len(x)
+    array_type = ct.c_double * n   
+    fun_c = astro_map["cassini2minlpC"]      
+    fun_c.argtypes = [ct.c_int, ct.POINTER(ct.c_double)]
+    fun_c.restype = ct.c_double  
+    try: # function is only defined inside bounds
+        dv = fun_c(n, array_type(*x))
+    except Exception as ex:
+        print(ex)
+        dv = 1E99
+    tof = sum(x[4:9])
+    launch_time = x[0] 
+    return [dv, tof, launch_time]
+ 
 class python_fun(object):
     
     def __init__(self, cfun, bounds):
@@ -151,4 +266,5 @@ class python_fun(object):
                 val = 1E10
         except Exception as ex:
             val = 1E10
-        return val
+        return val 
+

fcmaes/bitecpp.py

@@ -0,0 +1,107 @@
+# Copyright (c) Dietmar Wolz.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory.
+
+""" Implements a stochastic non-linear
+    bound-constrained derivative-free optimization method.
+    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 PCG64DXSM, Generator
+from scipy.optimize import OptimizeResult, Bounds
+from fcmaes.evaluator import _check_bounds, mo_call_back_type, callback_so, libcmalib
+
+from typing import Optional, Callable
+from numpy.typing import ArrayLike
+
+os.environ['MKL_DEBUG_CPU_TYPE'] = '5'
+
+def minimize(fun: Callable[[ArrayLike], float],
+             bounds: Optional[Bounds] = None,
+             x0: Optional[ArrayLike] = None,
+             max_evaluations: Optional[int] = 100000,
+             stop_fitness: Optional[float] = -np.inf,
+             M: Optional[int] = 1,
+             popsize: Optional[int] = 0,
+             stall_criterion: Optional[int]  = 0,
+             rg: Optional[Generator]  = Generator(PCG64DXSM()),
+             runid: Optional[int] = 0) -> OptimizeResult:
+    """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) -> 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.
+            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.  
+    max_evaluations : int, optional
+        Forced termination after ``max_evaluations`` function evaluations.
+    stop_fitness : float, optional 
+         Limit for fitness value. If reached minimize terminates.
+    M : int, optional 
+        Depth to use, 1 for plain CBiteOpt algorithm, >1 for CBiteOptDeep. Expected range is [1; 36].
+    popsize = int, optional
+        initial population size.
+    stall_criterion : int, optional 
+        Terminate if stall_criterion*128*evaluations stalled, Not used if <= 0
+    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   
+    array_type = ct.c_double * dim 
+    c_callback = mo_call_back_type(callback_so(fun, dim))
+    res = np.empty(dim+4)
+    res_p = res.ctypes.data_as(ct.POINTER(ct.c_double))
+    try:
+        optimizeBite_C(runid, c_callback, dim, int(rg.uniform(0, 2**32 - 1)), 
+                           None if x0 is None else array_type(*guess), 
+                           None if lower is None else array_type(*lower), 
+                           None if upper is None else array_type(*upper), 
+                           max_evaluations, stop_fitness, M, popsize, stall_criterion, 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)
+
+if not libcmalib is None: 
+    
+    optimizeBite_C = libcmalib.optimizeBite_C
+    optimizeBite_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.c_int, ct.c_double, ct.c_int, ct.c_int, ct.c_int, ct.POINTER(ct.c_double)]
+       
+
+