coco-experiment 2.8.2__tar.gz → 2.8.4__tar.gz

{coco_experiment-2.8.2 → coco_experiment-2.8.4}/.gitignore

@@ -64,3 +64,5 @@ test/regression-test/bbob_noisy_regression_test/data_legacy/*.json
 test/regression-test/bbob_noisy_regression_test/results
 build/c/.vscode
 bare_problem.c
+test/regression-test/create/exdata
+test/regression-test/exdata

{coco_experiment-2.8.2 → coco_experiment-2.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: coco-experiment
-Version: 2.8.2
+Version: 2.8.4
 Summary: Benchmarking framework for all types of black-box optimization algorithms.
 Project-URL: Homepage, https://github.com/numbbo/coco-experiment
 Project-URL: Documentation, https://numbbo.github.io/coco-doc/apidocs/cocoex/
@@ -11,14 +11,13 @@ License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.8
-Requires-Dist: numpy>=1.24.0
+Requires-Python: >=3.12
+Requires-Dist: numpy>=1.26.0
 Description-Content-Type: text/markdown
 
 <h1 align="center">

{coco_experiment-2.8.2 → coco_experiment-2.8.4}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["meson-python", "Cython >= 3.0.6", "wheel", "numpy"]
+requires = ["meson-python >= 0.22", "Cython >= 3.3", "wheel", "numpy >= 2.5"]
 build-backend = 'mesonpy'
 
 [project]
@@ -22,21 +22,20 @@ authors = [
 ]
 description = 'Benchmarking framework for all types of black-box optimization algorithms.'
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.12"
 license = { text = "BSD-3-Clause" }
 classifiers = [
     "Development Status :: 4 - Beta",
     "License :: OSI Approved :: BSD License",
     "Programming Language :: Python",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Programming Language :: Python :: Implementation :: CPython",
 ]
 dependencies = [
-    "numpy >= 1.24.0",
+    "numpy >= 1.26.0",
 ]
 dynamic = ["version"]
 
@@ -76,5 +75,5 @@ path = "src/cocoex/_version.py"
 
 [dependency-groups]
 dev = [
-    "build>=1.2",
+    "build>=1.6",
 ]

{coco_experiment-2.8.2 → coco_experiment-2.8.4}/src/cocoex/__init__.py

@@ -19,6 +19,7 @@ from . import noiser # noqa: F401
 from . import solvers # noqa: F401
 from . import utilities # noqa: F401
 from . import exceptions # noqa: F401
+# from . import test # noqa: F401  # gives a circular import, why???
 from .interface import Observer as _Observer
 from .interface import Problem as _Problem
 from .interface import Suite as _Suite 

{coco_experiment-2.8.2 → coco_experiment-2.8.4}/src/cocoex/_version.py

@@ -1,7 +1,7 @@
 # file generated by fabricate
 # Do not change, do not track in version control!
 
-__version__ = "2.8.2"
+__version__ = "2.8.4"
 version = __version__
 
 if __name__ == "__main__":

{coco_experiment-2.8.2 → coco_experiment-2.8.4}/src/cocoex/coco.c

@@ -26241,14 +26241,16 @@ static void coco_observer_targets_free(coco_observer_targets_t *targets) {
  * dim*1, dim*2, dim*5, 10*dim*1, 10*dim*2, 10*dim*5, 100*dim*1, 100*dim*2,
  * 100*dim*5, ...
  */
-static coco_observer_evaluations_t *coco_observer_evaluations(const char *base_evaluations, const size_t dimension) {
+static coco_observer_evaluations_t *coco_observer_evaluations(const size_t number_evaluation_triggers, 
+                                                              const char *base_evaluations, 
+                                                              const size_t dimension) {
 
   coco_observer_evaluations_t *evaluations = (coco_observer_evaluations_t *)coco_allocate_memory(sizeof(*evaluations));
 
   /* First trigger */
   evaluations->value1 = 1;
   evaluations->exponent1 = 0;
-  evaluations->number_of_triggers = OBSERVER_DEFAULT_NUMBER_OF_EVALUATION_TRIGGERS;
+  evaluations->number_of_triggers = number_evaluation_triggers;
 
   /* Second trigger */
   evaluations->base_evaluations =
@@ -26381,6 +26383,12 @@ static coco_observer_t *coco_observer_allocate(
   observer->logger_free_function = NULL;
   observer->restart_function = NULL;
   observer->is_active = 1;
+  coco_debug("Function coco_observer_allocate() called with values: result_folder: %s, observer_name: %s, algorithm_name: %s, "
+             "algorithm_info: %s, settings: %s, number_target_triggers: %lu, log_target_precision: %e, lin_target_precision: %e, "
+             "number_evaluation_triggers: %lu, base_evaluation_triggers: %s, precision_x: %d, precision_f: %d, precision_g: %d, "
+             "log_discrete_as_int: %d", result_folder, observer_name, algorithm_name, algorithm_info, settings, (unsigned long)number_target_triggers, 
+             log_target_precision, lin_target_precision, (unsigned long)number_evaluation_triggers, base_evaluation_triggers, precision_x, precision_f, 
+             precision_g, log_discrete_as_int);
   return observer;
 }
 
@@ -27252,8 +27260,8 @@ static coco_problem_t *logger_bbob(coco_observer_t *observer, coco_problem_t *in
   /* Initialize triggers performance and evaluation triggers depending on the observer option */
   logger_data->targets = coco_observer_targets(suite->known_optima, observer->lin_target_precision,
                                                observer->number_target_triggers, observer->log_target_precision);
-  logger_data->evaluations =
-      coco_observer_evaluations(observer->base_evaluation_triggers, inner_problem->number_of_variables);
+  logger_data->evaluations = coco_observer_evaluations(
+    observer->number_evaluation_triggers, observer->base_evaluation_triggers, inner_problem->number_of_variables);
   logger_data->mdat_targets = coco_observer_targets(suite->known_optima, observer->lin_target_precision,
                                                     observer->number_target_triggers, observer->log_target_precision);
 
@@ -27266,7 +27274,7 @@ static coco_problem_t *logger_bbob(coco_observer_t *observer, coco_problem_t *in
   observer_data->observed_problem = problem;
   return problem;
 }
-#line 510 "coco_observer.c"
+#line 518 "coco_observer.c"
 #line 1 "logger_bbob_old.c"
 /**
  * @file logger_bbob_old.c
@@ -27919,8 +27927,8 @@ static coco_problem_t *logger_bbob_old(coco_observer_t *observer, coco_problem_t
 
   /* Initialize triggers based on target values and number of evaluations */
   logger_data->targets = coco_observer_log_targets(observer->number_target_triggers, observer->log_target_precision);
-  logger_data->evaluations =
-      coco_observer_evaluations(observer->base_evaluation_triggers, inner_problem->number_of_variables);
+  logger_data->evaluations = coco_observer_evaluations(
+    observer->number_evaluation_triggers, observer->base_evaluation_triggers, inner_problem->number_of_variables);
 
   problem =
       coco_problem_transformed_allocate(inner_problem, logger_data, logger_bbob_old_free, observer->observer_name);
@@ -27929,7 +27937,7 @@ static coco_problem_t *logger_bbob_old(coco_observer_t *observer, coco_problem_t
   bbob_old_logger_is_open = 1;
   return problem;
 }
-#line 511 "coco_observer.c"
+#line 519 "coco_observer.c"
 #line 1 "logger_biobj.c"
 /**
  * @file logger_biobj.c
@@ -29616,7 +29624,8 @@ static logger_biobj_indicator_t *logger_biobj_indicator(const logger_biobj_data_
 
   indicator->targets = coco_observer_targets(suite->known_optima, observer->lin_target_precision,
                                              observer->number_target_triggers, observer->log_target_precision);
-  indicator->evaluations = coco_observer_evaluations(observer->base_evaluation_triggers, problem->number_of_variables);
+  indicator->evaluations = coco_observer_evaluations(observer->number_evaluation_triggers, observer->base_evaluation_triggers, 
+                                                     problem->number_of_variables);
 
   /* Prepare the info file */
   path_name = coco_allocate_string(COCO_PATH_MAX + 1);
@@ -30253,7 +30262,7 @@ static coco_problem_t *logger_biobj(coco_observer_t *observer, coco_problem_t *i
   observer_data->observed_problem = problem;
   return problem;
 }
-#line 512 "coco_observer.c"
+#line 520 "coco_observer.c"
 #line 1 "logger_rw.c"
 /**
  * @file logger_rw.c
@@ -30589,7 +30598,7 @@ static coco_problem_t *logger_rw(coco_observer_t *observer, coco_problem_t *inne
 
   return problem;
 }
-#line 513 "coco_observer.c"
+#line 521 "coco_observer.c"
 #line 1 "logger_toy.c"
 /**
  * @file logger_toy.c
@@ -30778,7 +30787,7 @@ static coco_problem_t *logger_toy(coco_observer_t *observer, coco_problem_t *inn
 
   return problem;
 }
-#line 514 "coco_observer.c"
+#line 522 "coco_observer.c"
 
 /**
  * Currently, four observers are supported:
@@ -31544,7 +31553,7 @@ void coco_archive_free(coco_archive_t *archive) {
  * don't change, don't track in version control!
  */
 
-const char *coco_version = "2.8.2";
+const char *coco_version = "2.8.4";
 #line 1 "coco_runtime_c.c"
 /**
  * @file coco_runtime_c.c

{coco_experiment-2.8.2 → coco_experiment-2.8.4}/src/cocoex/interface.pyx

@@ -83,6 +83,7 @@ cdef extern from "coco.h":
     void bbob_problem_best_parameter_print(const coco_problem_t *problem)
     void bbob_biobj_problem_best_parameter_print(const coco_problem_t *problem)
 
+cdef extern double coco_problem_get_best_value(coco_problem_t *p)  # copied from bare_problem.pyx
 
 cdef bytes _bstring(s):
     if type(s) is bytes:
@@ -424,7 +425,7 @@ cdef class Suite:
             % (self.name, self.instance, self.options,
                len(self), '' if len(self) == 1 else 's',
                '' if len(self.dimensions) == 1 else 's',
-               '%d=%d' % (min(self.dimensions), max(self.dimensions)))
+               '%d-%d' % (min(self.dimensions), max(self.dimensions)))
     def __len__(self):
         return len(self._indices)
 
@@ -556,7 +557,7 @@ cdef class Problem:
             raise RuntimeError("Problem already initialized")
         if problem == NULL:
             raise ValueError("in Problem._initialize(problem,...): problem is NULL")
-        self.problem = problem
+        self.problem = problem  # should probably be private ._problem?
         self._problem_index = coco_problem_get_suite_dep_index(self.problem)
         self._do_free = free
         self._list_of_observers = []
@@ -783,6 +784,12 @@ cdef class Problem:
         """
         assert(self.problem)
         return bool(coco_problem_final_target_hit(self.problem))
+    @property
+    def _best_value(self):
+        """return best f-value
+        """
+        assert(self.problem)
+        return coco_problem_get_best_value(self.problem)
     #@property
     #def final_target_fvalue1(self):
     #    assert(self.problem)

{coco_experiment-2.8.2 → coco_experiment-2.8.4}/src/cocoex/noiser.py

@@ -8,8 +8,12 @@ import json
 import numpy as np  # for checking finite values
 
 _frozen_noise = True
-math_floor = int
 parameters_file = 'noiser_parameters.json'
+'''default file name where to save current parameters of `Noisifier`'''
+save_parameters = False
+'''flag whether `Noisifier.__init__` saves noise parameters in file'''
+
+math_floor = int
 
 def rand(x, i=0):
     """return a uniform random value seeded with ``x[:2]`` and `i`"""
@@ -20,7 +24,7 @@ def randn(x, i=0):
 def randc(x, i=0):
     """return a Cauchy random value seeded with ``x[:2]`` and `i`.
 
-    We observe that median |Z| = 1 and p(pi x Z / 2 > a) = 1/a.
+    We observe that ``median(|Z|) == 1`` and ``p(pi x Z / 2 > a) == 1/a``.
     """
     return _cauchy(1, _seed(x, i))[0]
 
@@ -52,11 +56,12 @@ class Noisifier:
         ### prepare
         suite = cocoex.Suite(suite_name, "", "")
         observer = cocoex.Observer(suite_name, "")
+        noisifier = cocoex.noiser.Noisifier()  # wrapper without internal state
 
         ### go
         for problem in suite:  # this loop may take several minutes or more
             problem.observe_with(observer)  # generates the data for cocopp
-            problem = cocoex.noiser.Noisifier().noisify(problem)  # a Noisifier
+            problem = noisifier.noisify(problem)  # wrap problem as noisy
             fmin(problem, problem.initial_solution, disp=False)
 
     The `problem` is now a `Noisifier` but it still abides by the interface
@@ -70,13 +75,35 @@ class Noisifier:
     noise generator and the numbers scaled by pi/2 such that P(number > k)
     equals about 1/k when k >= 5.
 
+    Parameter settings are by default saved to the file indicated by the module
+    global variable `cocoex.noiser.parameters_file` if
+    ``bool(cocoex.noiser.save_parameters) is True``.
+
+    A minimal regression test:
+
+    >>> import cocoex
+    >>> def eq(x, y):
+    ...     return [cocoex.utilities.about_equal(xi, yi)
+    ...             for xi, yi in zip(x, y)]
+    >>> def fun(x):
+    ...     return 2 * x[0], 3 * x[1]
+
+    >>> n = cocoex.noiser.Noisifier(p_add=.5)
+    >>> f = n.noisify(fun)
+    >>> assert all(eq(f([1, 2]), [2, 41.39010606165791])
+    ...            ), f([1, 2])
+    >>> assert all(eq(f([2, 3, 4]), [11.518074565992698, 9.705537168513859])
+    ...            ), f([2, 3, 4])  # x[2:] have no influence here
+    >>> assert all(eq(f([-1, 2]), [-2, 6])
+    ...            ), f([-1, 2])
+
     See also https://github.com/numbbo/coco-experiment/issues/36 and
     https://github.com/numbbo/coco-experiment/blob/main/build/python/example/example_experiment_complete.py
 
     """
     p_add_single_default = 0.2
     def __init__(self, p_add=None, p_subtract=0.0, p_epsilon=0.0, epsilon=1e-4,
-                 rands=(rand, randn, randc)):
+                 rands=(rand, randn, randc), filename=None):
         """constructor with 4 optional parameters for the noise model,
 
         `p_add`: probability for adding a positive heavy tail random value
@@ -89,6 +116,11 @@ class Noisifier:
         `p_epsilon`: probability for adding a Gaussian random value
 
         `epsilon`: standard deviation of the Gaussian random value
+
+        `filename`: for saving parameter setting, if not given use module global
+        variable `cocoex.noiser.parameters_file`, saving depends on the module
+        variable `save_parameters`.
+
         """
         if p_add is None:
             if p_subtract == p_epsilon == 0:
@@ -97,15 +129,17 @@ class Noisifier:
                 p_add = 0.0
         self._params = {k: v for k, v in locals().items() if k != 'self'}
         if sum(self._params[p] for p in ('p_subtract', 'p_add')) > 1:
-            warnings.warn("p_subtract={0} + p_add={1} > 1, hence p_add is interpreted"
-                          " as ``1-p_subtract``"
+            warnings.warn("p_subtract={0} + p_add={1} > 1, hence p_add"  # noqa: UP030
+                          " is interpreted as ``1-p_subtract``"
                           .format(self._params['p_subtract'], self._params['p_add']))
         if p_add < 0 or p_subtract < 0 or p_epsilon < 0 or epsilon < 0:
-            raise ValueError("parameters cannot be negative but were {0}"
-                             .format(self._params))
+            raise ValueError("parameters cannot be negative"  # noqa: UP030, UP032
+                             " but were {0}".format(self._params))
         if p_epsilon > 0 and epsilon == 0:
-            warnings.warn("p_epsilon = {0} > 0 is not effective because epsilon = 0"
-                          .format(p_epsilon))
+            warnings.warn("p_epsilon = {0} > 0 is not effective"  # noqa: UP030, UP032
+                          " because epsilon = 0".format(p_epsilon))
+        if save_parameters:
+            self.save_parameters()
 
     def noisify(self, problem):
         """wrap `problem` with frozen noise"""
@@ -116,23 +150,19 @@ class Noisifier:
     def parameters(self):
         return {k: v for (k, v) in self._params.items() if k.startswith(('p_', 'eps'))}
 
-    def _dump_params(self):
-        with open(parameters_file, 'wt') as fp:
+    def save_parameters(self, filename=None):
+        """save parameter `dict` to a `json` file"""
+        with open(filename or self._params.get('filename')
+                           or parameters_file, 'wt') as fp:
             json.dump(self.parameters, fp)
 
-    def _load_params(self, filename=parameters_file, warn_errors=(FileNotFoundError,), ignore_errors=()):
-        try:
-            with open(parameters_file, 'rt') as fp:
-                return json.load(fp)
-        except warn_errors as e:
-            warnings.warn('NoisifyProblem._load_params raised the exception "{0}"'.format(e))
-        except ignore_errors:
-            pass
-        return {}
+    def _set_params(self, filename=None, **kwargs):
+        """set parameters from file `filename` or filename passed at
 
-    def _set_params(self, filename=parameters_file, **kwargs):
-        """set parameters from file `filename`"""
-        self._params.update(self._load_params(filename), **kwargs)
+        instantiation or `cocoex.noiser.parameters_file`.
+        """
+        self._params.update(_read_params(filename or self._params.get('filename')
+                                                  or parameters_file), **kwargs)
 
     def __getattr__(self, name):
         """pretend to be a COCO `problem` as passed in `noisify`"""
@@ -192,6 +222,20 @@ class Noisifier:
         assert np.isfinite(n)
         return n
 
+
+def _read_params(filename=None,
+                 warn_errors=(FileNotFoundError,), ignore_errors=()):
+    """read parameters from a json file and return a parameters `dict`"""
+    try:
+        with open(filename or parameters_file, 'rt') as fp:
+            return json.load(fp)
+    except warn_errors as e:
+        warnings.warn('noiser._read_params raised the exception: ' + str(e))
+    except ignore_errors:
+        pass
+    return {}
+
+
 _seed_weights = [1.23468, 2.34579]  # otherwise, coordinate search would be noisefree
 _seeds = collections.deque(maxlen=99)  # for the record only
 def _seed(x, i=0):

{coco_experiment-2.8.2 → coco_experiment-2.8.4}/src/cocoex/utilities.py

@@ -269,7 +269,7 @@ class ProblemNonAnytime:
     ``p_unobserved.evaluations >= p_observed.evaluations``.
 
     """
-    inherited_constant_attributes = [
+    inherited_constant_attributes = [  # easier and better solved by defining __getattr__!?
             'dimension',
             'id',
             'index',
@@ -377,7 +377,7 @@ class SameFunction:
     >>> from cocoex.utilities import SameFunction
     >>>
     >>> suite = cocoex.Suite('bbob', '', '')
-    >>> already_seen = SameFunction()
+    >>> already_seen = seen = SameFunction()
     >>> processed = 0
     >>> for problem in suite:
     ...     if already_seen(problem.id) > 5:
@@ -600,6 +600,9 @@ class ExperimentRepeater:
     sweeps until some given budget is exhaused, namely, ``budget_multiplier
     * dimension``.
 
+    CAVEAT: this works as desired only when all instances of the same problem
+    are run in the same batch, as it is the case with `BatchScheduler`.
+
     Example code snippet::
 
         [...]
@@ -934,6 +937,9 @@ class ExperimentRepeater:
 class BatchScheduler:
     """Facilitate to run a benchmarking experiment in independent batches.
 
+    All instances of the same ``(function, dimension)`` belong to the same
+    batch, in order to allow for uniform instance repetitions.
+
     The batch scheduler crucially assumes that in each batch the same
     problems are given *in the same order* when calling `is_in_batch`.
 
@@ -953,10 +959,13 @@ class BatchScheduler:
     ``batch_to_execute in (0,1,2,3)`` to generate the full experimental
     data.
 
-    Details: to get a more even time distribution over all batches, it
-    seems advisable that the number of functions is not divisible by the
-    number of batches. That is, 4 (or 6 or 8 or 12) batches is not likely
-    to be ideal on the `'bbob'` testbed of 24 functions.
+    Details: while making the number of functions not divisible by the number of
+    batches may sometimes achieve a more even time distribution over all
+    batches, in practice, it is advisable to keep each function in a single or a
+    few batches as it is enforced by the `BatchScheduler`. Hence, for the 24
+    functions of the `'bbob'` testbed, having 48 or 24 or 12 or 8 or 6 or 4
+    batches is advisable. Additionally, it can be useful to run the largest
+    dimension in a separate launch (with at most 24 batches in this case).
     """
     def __init__(self, number_of_batches, batch_to_execute):
         """distribute over `number_of_batches` batches and execute