Update pypop7/optimizers/cc/hcc.py

pypop7/optimizers/cc/hcc.py

@@ -2,8 +2,8 @@
 
 import numpy as np
 
-from pypop7.optimizers.es.lmcma import LMCMA  # for upper-level
-from pypop7.optimizers.es.cmaes import CMAES  # for lower-level
+from pypop7.optimizers.es.lmcma import LMCMA  # for upper-level optimization
+from pypop7.optimizers.es.cmaes import CMAES  # for lower-level optimization
 from pypop7.optimizers.cc import CC
 
 
@@ -31,7 +31,7 @@ class HCC(CC):
 
     Examples
     --------
-    Use the optimizer to minimize the well-known test function
+    Use the optimizer `HCC` to minimize the well-known test function
     `Rosenbrock <http://en.wikipedia.org/wiki/Rosenbrock_function>`_:
 
     .. code-block:: python
@@ -42,16 +42,15 @@ class HCC(CC):
        >>> from pypop7.optimizers.cc.hcc import HCC
        >>> problem = {'fitness_function': rosenbrock,  # define problem arguments
        ...            'ndim_problem': 2,
-       ...            'lower_boundary': -5*numpy.ones((2,)),
-       ...            'upper_boundary': 5*numpy.ones((2,))}
+       ...            'lower_boundary': -5.0*numpy.ones((2,)),
+       ...            'upper_boundary': 5.0*numpy.ones((2,))}
        >>> options = {'max_function_evaluations': 5000,  # set optimizer options
-       ...            'seed_rng': 2022,
-       ...            'x': 3*numpy.ones((2,))}
+       ...            'seed_rng': 2022}
        >>> hcc = HCC(problem, options)  # initialize the optimizer class
        >>> results = hcc.optimize()  # run the optimization process
        >>> # return the number of function evaluations and best-so-far fitness
        >>> print(f"HCC: {results['n_function_evaluations']}, {results['best_so_far_y']}")
-       HCC: 5000, 0.0006576371426980234
+       HCC: 5000, 0.0057391910865252
 
     For its correctness checking of coding, we cannot provide the code-based repeatability report, since this
     implementation combines two different papers. To our knowledge, few well-designed open-source code of `CC` is
@@ -131,7 +130,7 @@ def optimize(self, fitness_function=None, args=None):
         lmcma.start_time = time.time()
         lmcma.fitness_function = self._evaluate_fitness
         # run lower-level CMA-ES
-        x_s, mean_s, ps_s, pc_s, cm_s, ee_s, ea_s, y_s = [], [], [], [], [], [], [], []  # for lower-level CMA-ES
+        x_s, mean_s, ps_s, pc_s, cm_s, ee_s, ea_s, y_s, d_s = [], [], [], [], [], [], [], [], []
         while not self._check_terminations():
             self._print_verbose_info(fitness, y)
             y = []
@@ -150,15 +149,16 @@ def optimize(self, fitness_function=None, args=None):
                     if self._check_terminations():
                         break
 
-                    x, mean, p_s, p_c, cm, eig_ve, eig_va, yy = opt.initialize()
+                    x, mean, p_s, p_c, cm, e_ve, e_va, yy, d = opt.initialize()
                     x_s.append(x)
                     mean_s.append(mean)
                     ps_s.append(p_s)
                     pc_s.append(p_c)
                     cm_s.append(cm)
-                    ee_s.append(eig_ve)
-                    ea_s.append(eig_va)
+                    ee_s.append(e_ve)
+                    ea_s.append(e_va)
                     y_s.append(yy)
+                    d_s.append(d)
             else:
                 for i, opt in enumerate(sub_optimizers):
                     ii = range(i*self.ndim_subproblem, np.minimum((i + 1)*self.ndim_subproblem, self.ndim_problem))
@@ -170,13 +170,13 @@ def sub_function(sub_x):  # to define sub-function for each sub-optimizer
                     opt.fitness_function = sub_function
                     opt.max_function_evaluations = (opt.n_function_evaluations +
                                                     self.max_function_evaluations - self.n_function_evaluations)
-                    x_s[i], y_s[i] = opt.iterate(x_s[i], mean_s[i], ee_s[i], ea_s[i], y_s[i], args)
+                    x_s[i], y_s[i], d_s[i] = opt.iterate(x_s[i], mean_s[i], ee_s[i], ea_s[i], y_s[i], d_s[i], args)
                     y.extend(y_s[i])
                     if self._check_terminations():
                         break
-                    opt.n_generations += 1
+                    opt._n_generations += 1
                     mean_s[i], ps_s[i], pc_s[i], cm_s[i], ee_s[i], ea_s[i] = opt.update_distribution(
-                        x_s[i], mean_s[i], ps_s[i], pc_s[i], cm_s[i], ee_s[i], ea_s[i], y_s[i])
+                        x_s[i], ps_s[i], pc_s[i], cm_s[i], ee_s[i], ea_s[i], y_s[i], d_s[i])
                 if self.best_so_far_y < lmcma.best_so_far_y:  # to communicate between upper and lower levels
                     lm_mean = np.copy(self.best_so_far_x)
             self._n_generations += 1