Optimization of katsuura function calculation

ChangeLog.md

@@ -1,3 +1,8 @@
+# Version 1.0.3
+
++ Optimized katsuura_func performance, at 1M ndim > 80x speedup
+
+---------------------------------------------------------------------
 # Version 1.0.2
 
 + Fix modified_schwefel_func() in operator.py

docs/source/conf.py

@@ -29,7 +29,7 @@
 author = 'Thieu'
 
 # The full version, including alpha/beta/rc tags
-release = '1.0.2'
+release = '1.0.3'
 
 
 # -- General configuration ---------------------------------------------------

docs/source/pages/quick_start.rst

@@ -8,7 +8,7 @@ Installation
 
 Install the `current PyPI release <https://pypi.python.org/pypi/opfunu/>`_::
 
-   $ pip install opfunu==1.0.2
+   $ pip install opfunu==1.0.3
 
 
 Or install the development version from GitHub::

opfunu/__init__.py

@@ -29,7 +29,7 @@
 # >>> opfunu.plot_2d(f22005, n_space=1000, ax=None)
 # >>> opfunu.plot_3d(f22005, n_space=1000, ax=None)
 
-__version__ = "1.0.2"
+__version__ = "1.0.3"
 
 import inspect
 import re

opfunu/cec_based/cec.py

@@ -204,6 +204,10 @@ def check_ndim_and_bounds(self, ndim=None, dim_max=None, bounds=None, default_bo
                 if self.dim_changeable:
                     if type(ndim) is int and ndim > 1:
                         if dim_max is None or ndim <= dim_max:
+                            # Check if ndim in supported dimensions
+                            if self.dim_supported is not None and ndim not in self.dim_supported:
+                                raise ValueError(f'{self.__class__.__name__} ndim not in supported dimensions '
+                                                 f'{self.dim_supported}')
                             self._ndim = int(ndim)
                             self._bounds = np.array([default_bounds[0] for _ in range(self._ndim)])
                         else:

opfunu/utils/operator.py

@@ -240,8 +240,10 @@ def katsuura_func(x):
     x = np.array(x).ravel()
     ndim = len(x)
     result = 1.0
+    powers_of_two = 2 ** np.arange(1, 34)
+    reciprocals_of_two = 1 / powers_of_two
     for idx in range(0, ndim):
-        temp = np.sum([np.abs(2 ** j * x[idx] - np.round(2 ** j * x[idx])) / 2 ** j for j in range(1, 33)])
+        temp = np.sum(np.abs(powers_of_two * x[idx] - np.round(powers_of_two * x[idx])) * reciprocals_of_two)
         result *= (1 + (idx + 1) * temp) ** (10.0 / ndim ** 1.2)
     return (result - 1) * 10 / ndim ** 2
 

setup.py

@@ -15,7 +15,7 @@ def readme():
 
 setup(
     name="opfunu",
-    version="1.0.2",
+    version="1.0.3",
     author="Thieu",
     author_email="nguyenthieu2102@gmail.com",
     description="Opfunu: An Open-source Python Library for Optimization Benchmark Functions",