mango 0.2.0__tar.gz → 0.2.2__tar.gz

{mango-0.2.0/mango.egg-info → mango-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mango
-Version: 0.2.0
+Version: 0.2.2
 Summary: Library with a collection of usefull classes and methods to DRY
 Author-email: baobab soluciones <mango@baobabsoluciones.es>
 License: Apache Software License
@@ -51,8 +51,21 @@ Requires-Dist: plotly<=5.17.0; extra == "plot"
 Provides-Extra: shap
 Requires-Dist: shap[plots]==0.43.0; extra == "shap"
 
-MANGO
------
+Mango
+------
+
+.. image:: https://img.shields.io/pypi/v/mango?label=version&logo=python&logoColor=white&style=for-the-badge&color=E58164
+   :alt: PyPI
+   :target: https://pypi.python.org/pypi/cornflow-client
+.. image:: https://img.shields.io/pypi/l/mango?color=blue&style=for-the-badge
+  :alt: PyPI - License
+  :target: https://github.com/baobabsoluciones/cornflow/blob/master/LICENSE
+.. image:: https://img.shields.io/github/actions/workflow/status/baobabsoluciones/mango/build_docs.yml?label=docs&logo=github&style=for-the-badge
+   :alt: GitHub Workflow Status
+   :target: https://github.com/baobabsoluciones/cornflow/actions
+.. image:: https://img.shields.io/codecov/c/gh/baobabsoluciones/mango?flag=unit-tests&label=coverage&logo=codecov&logoColor=white&style=for-the-badge&token=0KKRF3J95L
+    :alt: Codecov
+    :target: https://app.codecov.io/gh/baobabsoluciones/mango
 
 This a library containing several modules developed by the team at baobab soluciones. These functions, classes and methods are based on their experience, understanding and knowledge of the Python language and its ecosystem.
 

mango-0.2.2/README.rst

@@ -0,0 +1,19 @@
+Mango
+------
+
+.. image:: https://img.shields.io/pypi/v/mango?label=version&logo=python&logoColor=white&style=for-the-badge&color=E58164
+   :alt: PyPI
+   :target: https://pypi.python.org/pypi/cornflow-client
+.. image:: https://img.shields.io/pypi/l/mango?color=blue&style=for-the-badge
+  :alt: PyPI - License
+  :target: https://github.com/baobabsoluciones/cornflow/blob/master/LICENSE
+.. image:: https://img.shields.io/github/actions/workflow/status/baobabsoluciones/mango/build_docs.yml?label=docs&logo=github&style=for-the-badge
+   :alt: GitHub Workflow Status
+   :target: https://github.com/baobabsoluciones/cornflow/actions
+.. image:: https://img.shields.io/codecov/c/gh/baobabsoluciones/mango?flag=unit-tests&label=coverage&logo=codecov&logoColor=white&style=for-the-badge&token=0KKRF3J95L
+    :alt: Codecov
+    :target: https://app.codecov.io/gh/baobabsoluciones/mango
+
+This a library containing several modules developed by the team at baobab soluciones. These functions, classes and methods are based on their experience, understanding and knowledge of the Python language and its ecosystem.
+
+The functions are divided in different modules so even though everything is imported the dependencies can be installed only for the modules that are needed.

mango-0.2.2/docs/source/conf.py

@@ -0,0 +1,46 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath("../../"))
+
+
+project = "mango"
+copyright = "2023, baobab soluciones"
+author = "baobab soluciones"
+# release = "0.2.0"
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = ["sphinx.ext.autodoc", "sphinx.ext.intersphinx", "sphinxcontrib.bibtex"]
+
+templates_path = ["templates"]
+exclude_patterns = ["build", "Thumbs.db", ".DS_Store"]
+
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = "shibuya"
+html_static_path = ["static"]
+
+# autodoc_mock_imports = ["mango"]
+autodoc_member_order = "bysource"
+autodoc_default_options = {"members": True, "inherited-members": True}
+
+import mango
+
+version = mango.__version__
+release = mango.__version__
+
+
+# Options for bibtex
+bibtex_bibfiles = ["./refs.bib"]
+bibtex_default_style = "plain"

mango-0.2.2/mango/__init__.py

@@ -0,0 +1,4 @@
+"""
+Main file
+"""
+__version__ = "0.2.2"

mango-0.2.2/mango/benchmark/__init__.py

@@ -0,0 +1 @@
+from .optimization import *

{mango-0.2.0 → mango-0.2.2}/mango/benchmark/optimization/ackley.py

@@ -7,15 +7,18 @@ def ackley(x: np.ndarray) -> float:
     General Ackley function.
 
     The Ackley function is widely used for testing optimization algorithms.
+
     In its two-dimensional form, it is characterized by a nearly flat outer region, and a large hole at the centre.
     The function poses a risk for optimization algorithms, particularly hillclimbing algorithms,
     to be trapped in one of its many local minima.
 
     The global minimum point of the function is: f(x) = 0, at x = (0, ..., 0)
 
-    :param :class:`np.ndarray` x: numpy array of floats. The values are evaluated in the range [-32.768, 32.768]
+    :param x: numpy array of floats. The values are evaluated in the range [-32.768, 32.768]
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
+    :doc-author: baobab soluciones
     """
     return (
         -20 * exp(-0.2 * sqrt(1 / len(x) * np.sum(np.square(x))))
@@ -29,7 +32,10 @@ def inverted_ackley(x: np.ndarray) -> float:
     """
     Inverted Ackley function.
 
-    :param :class:`np.ndarray` x: numpy array of floats
+    Some description of the function.
+
+    :param x: numpy array of floats
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.2}/mango/benchmark/optimization/bukin.py

@@ -11,7 +11,8 @@ def bukin_function_6(x: np.array) -> float:
 
     The global minima is at (-10, 1) with a value of 0.
 
-    :param :class:`np.array` x: array of floats. Values are between [-15, 5] for x1 and [-3, 3] for x2
+    :param x: array of floats. Values are between [-15, 5] for x1 and [-3, 3] for x2
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """
@@ -22,7 +23,8 @@ def inverted_bukin_function_6(x: np.array) -> float:
     """
     Inverted Bukin function N. 6.
 
-    :param :class:`np.array` x: array of floats. Values are between [-15, 5] for x1 and [-3, 3] for x2
+    :param x: array of floats. Values are between [-15, 5] for x1 and [-3, 3] for x2
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.2}/mango/benchmark/optimization/cross_in_tray.py

@@ -13,7 +13,8 @@ def cross_in_tray(x: np.array) -> float:
     The global mínima is located at x = (1.34941, 1.34941), (-1.34941, 1.34941), (1.34941, -1.34941)
     and (-1.34941, -1.34941) with a value of -2.06261
 
-    :param :class:`np.array` x: array of floats
+    :param x: array of floats
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """
@@ -36,7 +37,8 @@ def inverted_cross_in_tray(x: np.array) -> float:
     The Cross-in-tray function has many widespread local minima, which are regularly distributed
     This implementation inverts the function to test out the maximization
 
-    :param :class:`np.array` x: array of floats
+    :param x: array of floats
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.2}/mango/benchmark/optimization/dolan.py

@@ -9,7 +9,8 @@ def dolan_function_no2(x: np.array) -> float:
 
     The global minima is at [8.39045925, 4.81424707, 7.34574133, 68.88246895, 3.85470806] with a value of 10^-5
 
-    :param :class:`np.array` x: array of floats. Values are evaluated between [-100, 100]
+    :param x: array of floats. Values are evaluated between [-100, 100]
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """
@@ -27,7 +28,8 @@ def inverted_dolan_function_no2(x: np.array) -> float:
     """
     Inverted Dolan function No 2.
 
-    :param :class:`np.array` x: array of floats. Values are evaluated between [-100, 100]
+    :param x: array of floats. Values are evaluated between [-100, 100]
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.2}/mango/benchmark/optimization/drop_wave.py

@@ -11,7 +11,8 @@ def drop_wave(x: np.array) -> float:
 
     The global minima is located at x = (0, 0) with a value of -1
 
-    :param :class:`np.array` x: array of floats. Values usually are between -5.12 and 5.12.
+    :param x: array of floats. Values usually are between -5.12 and 5.12.
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """
@@ -29,7 +30,8 @@ def inverted_drop_wave(x: np.array) -> float:
 
     The global minima is located at x = (0, 0) with a value of -1
 
-    :param :class:`np.array` x: array of floats. Values usually are between -5.12 and 5.12.
+    :param x: array of floats. Values usually are between -5.12 and 5.12.
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.2}/mango/benchmark/optimization/egg_holder.py

@@ -12,7 +12,8 @@ def egg_holder(x: np.array) -> float:
     The function is usually evaluated on the square xi ∈ [-512, 512], for all i = 1, 2.
     The global mínima is located at x = (512, 404.2319) with a value of -959.6407
 
-    :param :class:`np.array` x: array of floats
+    :param x: array of floats
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """
@@ -28,7 +29,8 @@ def inverted_egg_holder(x: np.array) -> float:
     The Egg-holder function has many widespread local minima, which are regularly distributed
     This implementation inverts the function to test out the maximization
 
-    :param :class:`np.array` x: array of floats
+    :param x: array of floats
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.2}/mango/benchmark/optimization/gramacy_lee.py

@@ -1,26 +1,33 @@
 from math import sin, pi
+from typing import Union
 
+import numpy as np
 
-def gramacy_lee(x: list) -> float:
+
+def gramacy_lee(x: Union[np.array, list, float]) -> float:
     """
     Gramacy & Lee function.
 
     This function is multimodal, with a number of local minima. The global minimum is at x = 0.54.
 
-    :param list x: list of floats. Each value is usually between -0.5 and 2.5.
+    :param x: array or list with the value or the value itself. Each value is usually between -0.5 and 2.5.
+    :type x: :class:`numpy.array`, list or float
     :return: the value of the function
     :rtype: float
     """
+    if isinstance(x, float):
+        x = [x]
     return sin(10 * pi * x[0]) / (2 * x[0]) + (x[0] - 1) ** 4
 
 
-def inverted_gramacy_lee(x: list) -> float:
+def inverted_gramacy_lee(x: Union[np.array, list, float]) -> float:
     """
     Inverted Gramacy & Lee function.
 
     This function is multimodal, with a number of local minima. The global minimum is at x = 0.54.
 
-    :param list x: list of floats. Each value is usually between -0.5 and 2.5.
+    :param x: array or list with the value or the value itself. Each value is usually between -0.5 and 2.5.
+    :type x: :class:`numpy.array`, list or float
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.2}/mango/benchmark/optimization/griewank.py

@@ -1,5 +1,3 @@
-from math import prod, cos, sqrt
-
 import numpy as np
 
 
@@ -9,7 +7,10 @@ def griewank(x: np.array) -> float:
 
     The Griewank function has many widespread local minima, which are regularly distributed
 
-    :param :class:`np.array` x: array of floats
+    The global minima is located at [0, 0, ..., 0] with a value of 0
+
+    :param x: array of floats
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """
@@ -27,7 +28,8 @@ def inverted_griewank(x: np.array) -> float:
     The Griewank function has many widespread local minima, which are regularly distributed
     This implementation inverts the function to test out the maximization
 
-    :param :class:`np.array` x: array of floats
+    :param x: array of floats
+    :type x: :class:`numpy.ndarray`
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.2}/mango/benchmark/optimization/holder_table.py

@@ -1,7 +1,10 @@
 from math import sin, cos, exp, sqrt, pi
+from typing import Union
 
+import numpy as np
 
-def holder_table(x: list) -> float:
+
+def holder_table(x: Union[np.array, list]) -> float:
     """
     Holder function.
 
@@ -9,14 +12,15 @@ def holder_table(x: list) -> float:
     The global minima is at (8.05502, 9.66459), (-8.05502, 9.66459), (8.05502, -9.66459) and (-8.05502, -9.66459)
     with a value of -19.2085.
 
-    :param list x: list of floats. Each value is usually between -10 and 10.
+    :param x: array or list of floats. Each value is usually between -10 and 10.
+    :type x: :class:`numpy.array` or list
     :return: the value of the function
     :rtype: float
     """
     return -abs(sin(x[0]) * cos(x[1]) * exp(abs(1 - sqrt(x[0] ** 2 + x[1] ** 2) / pi)))
 
 
-def inverted_holder_table(x: list) -> float:
+def inverted_holder_table(x: Union[np.array, list]) -> float:
     """
     Inverted Holder function.
 
@@ -26,7 +30,8 @@ def inverted_holder_table(x: list) -> float:
     The global maxima is at (8.05502, 9.66459), (-8.05502, 9.66459), (8.05502, -9.66459) and (-8.05502, -9.66459)
     with a value of 19.2085.
 
-    :param list x: list of floats. Each value is usually between -10 and 10.
+    :param x: list of floats. Each value is usually between -10 and 10.
+    :type x: :class:`numpy.array` or list
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.2}/mango/benchmark/optimization/langermann.py

@@ -1,14 +1,21 @@
 from math import exp, pi, cos
+from typing import Union
 
+import numpy as np
 
-def langermann(x: list) -> float:
+
+def langermann(x: Union[np.array, list]) -> float:
     """
     Langermann function.
 
     The Langermann function is a multimodal problem. It has a fairly large number of local minima,
     widely separated and regularly distributed.
 
-    :param list x: list of floats. Each value is usually between 0 and 10.
+    This implementation is only for the two dimension version of the function using the values for a, c and m
+    proposed by Molga & Smutnicki (2005) :cite:p:`molga2005test`.
+
+    :param x: array or list of floats. Each value is usually between 0 and 10.
+    :type x: :class:`numpy.array` or list
     :return: the value of the function
     :rtype: float
     """
@@ -29,14 +36,15 @@ def langermann(x: list) -> float:
     )
 
 
-def inverted_langermann(x: list) -> float:
+def inverted_langermann(x: Union[np.array, list]) -> float:
     """
     Inverted Langermann function.
 
     The Langermann function is a multimodal problem. It has a fairly large number of local minima,
     widely separated and regularly distributed. This implementation inverts the function to test out the maximization
 
-    :param list x: list of floats. Each value is usually between 0 and 10.
+    :param x: array or list of floats. Each value is usually between 0 and 10.
+    :type x: :class:`numpy.array` or list
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.2}/mango/benchmark/optimization/levy.py

@@ -1,4 +1,5 @@
 from math import sin, pi
+from typing import Union
 
 import numpy as np
 
@@ -9,7 +10,8 @@ def levy(x: np.array) -> float:
 
     The global minima is at x = [1, 1, 1, ..., 1] and the function value is 0.
 
-    :param :class:`np.array` x: array of floats. Each value is usually between -10 and 10.
+    :param x: array of floats. Each value is usually between -10 and 10.
+    :type x: :class:`numpy.array`
     :return: the value of the function
     :rtype: float
     """
@@ -26,20 +28,22 @@ def inverted_levy(x: np.array) -> float:
     """
     Inverted Levy function.
 
-    :param :class:`np.array` x: array of floats. Each value is usually between -10 and 10.
+    :param x: array of floats. Each value is usually between -10 and 10.
+    :type x: :class:`numpy.array`
     :return: the value of the function
     :rtype: float
     """
     return -levy(x)
 
 
-def levy_function_no13(x: list) -> float:
+def levy_function_no13(x: Union[np.array, list]) -> float:
     """
     Levy function N. 13.
 
     The global minima is at x = [1, 1] and the function value is 0.
 
-    :param list x: list of floats. Each value is usually between -10 and 10.
+    :param x: array or list of floats. Each value is usually between -10 and 10.
+    :type x: :class:`numpy.array` or list
     :return: the value of the function
     :rtype: float
     :doc-author: baobab soluciones
@@ -51,13 +55,14 @@ def levy_function_no13(x: list) -> float:
     )
 
 
-def inverted_levy_no13(x: list) -> float:
+def inverted_levy_no13(x: Union[np.array, list]) -> float:
     """
     Inverted Levy function N. 13.
 
     The global minima is at x = [1, 1] and the function value is 0.
 
-    :param list x: list of floats. Each value is usually between -10 and 10.
+    :param x: list of floats. Each value is usually between -10 and 10.
+    :type x: :class:`numpy.array` or list
     :return: the value of the function
     :rtype: float
     :doc-author: baobab soluciones

{mango-0.2.0 → mango-0.2.2}/mango/benchmark/optimization/rastrigin.py

@@ -1,28 +1,34 @@
 from math import cos, pi
 
+import numpy as np
 
-def rastrigin(x: list) -> float:
+
+def rastrigin(x: np.array) -> float:
     """
     Rastrigin function.
 
     The Rastrigin function has several local minima. It is highly multimodal, but locations of the minima
     are regularly distributed.
 
-    :param list x: list of floats. Values usually are between -5.12 and 5.12.
+    The global minima is at [0, 0, ..., 0] with a value of 0
+
+    :param x: array of floats. Values usually are between -5.12 and 5.12.
+    :type x: :class:`npumpy.array`
     :return: the value of the function
     :rtype: float
     """
-    return 10 * len(x) + sum([i**2 - 10 * cos(2 * pi * i) for i in x])
+    return 10 * len(x) + np.sum(x**2 - 10 * np.cos(2 * pi * x))
 
 
-def inverse_rastrigin(x: list) -> float:
+def inverted_rastrigin(x: np.array) -> float:
     """
     Inverted Rastrigin function.
 
     The Rastrigin function has several local minima. It is highly multimodal, but locations of the minima
     are regularly distributed. This implementation inverts the function to test out the maximization
 
-    :param list x: list of floats. Values usually are between -5.12 and 5.12.
+    :param x: array of floats. Values usually are between -5.12 and 5.12.
+    :type x: :class:`npumpy.array`
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.2}/mango/benchmark/optimization/rosenbrock.py

@@ -1,4 +1,7 @@
-def rosenbrock(x: list) -> float:
+import numpy as np
+
+
+def rosenbrock(x: np.array) -> float:
     """
     Rosenbrock function.
 
@@ -8,16 +11,18 @@ def rosenbrock(x: list) -> float:
     The function is unimodal, and the global minimum lies in a narrow, parabolic valley.
     However, even though this valley is easy to find, convergence to the minimum is difficult (Picheny et al., 2012).
 
-    :param list x: list of floats. Values ussually are between -5 and 10
+    The global minima is at [1, 1, ..., 1] with a value of 0
+
+    :param x: array of floats. Values usually are between -5 and 10
+    :type x: :class:`numpy.array`
     :return: the value of the function
     :rtype: float
     """
-    return sum(
-        [100 * (x[i + 1] - x[i] ** 2) ** 2 + (1 - x[i]) ** 2 for i in range(len(x) - 1)]
-    )
+
+    return np.sum(100.0 * (x[1:] - x[:-1] ** 2.0) ** 2.0 + (1 - x[:-1]) ** 2.0, axis=0)
 
 
-def inverted_rosenbrock(x: list) -> float:
+def inverted_rosenbrock(x: np.array) -> float:
     """
     Inverted Rosenbrock function.
 
@@ -27,7 +32,8 @@ def inverted_rosenbrock(x: list) -> float:
     The function is unimodal, and the global minimum lies in a narrow, parabolic valley.
     However, even though this valley is easy to find, convergence to the minimum is difficult (Picheny et al., 2012).
 
-    :param list x: list of floats. Values ussually are between -5 and 10
+    :param x: array of floats. Values ussually are between -5 and 10
+    :type x: :class:`numpy.array`
     :return: the value of the function
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.2}/mango/benchmark/optimization/schaffer.py

@@ -1,7 +1,10 @@
 from math import sin, cos
+from typing import Union
 
+import numpy as np
 
-def schaffer_function_no2(x: list) -> float:
+
+def schaffer_function_no2(x: Union[np.array, list]) -> float:
     """
     Schaffer function N. 2.
 
@@ -9,7 +12,8 @@ def schaffer_function_no2(x: list) -> float:
 
     The global minima is at x [0, 0] with value 0
 
-    :param list x: A list of values. Values are evaluated between [-100, 100]
+    :param x: A list of values. Values are evaluated between [-100, 100]
+    :type x: :class:`numpy.array` or list
     :return: The value of the Schaffer function N. 2.
     :rtype: float
     """
@@ -18,7 +22,7 @@ def schaffer_function_no2(x: list) -> float:
     )
 
 
-def inverted_schaffer_function_no2(x: list) -> float:
+def inverted_schaffer_function_no2(x: Union[np.array, list]) -> float:
     """
     Inverted Schaffer function N. 2.
 
@@ -28,14 +32,15 @@ def inverted_schaffer_function_no2(x: list) -> float:
 
     The global maxima is at x [0, 0] with value 0
 
-    :param list x: A list of values. Values are evaluated between [-100, 100]
+    :param x: A list of values. Values are evaluated between [-100, 100]
+    :type x: :class:`numpy.array` or list
     :return: The value of the Inverted Schaffer function N. 2.
     :rtype: float
     """
     return -schaffer_function_no2(x)
 
 
-def schaffer_function_no4(x: list) -> float:
+def schaffer_function_no4(x: Union[np.array, list]) -> float:
     """
     Schaffer function N. 4.
 
@@ -43,7 +48,8 @@ def schaffer_function_no4(x: list) -> float:
 
     The global minima is at x [0, 1.253115] with value 0.292579
 
-    :param list x: A list of values. Values are evaluated between [-100, 100]
+    :param x: array or list of values. Values are evaluated between [-100, 100]
+    :type x: :class:`numpy.array` or list
     :return: The value of the Schaffer function N. 4.
     :rtype: float
     """
@@ -52,7 +58,7 @@ def schaffer_function_no4(x: list) -> float:
     )
 
 
-def inverted_schaffer_function_no4(x: list) -> float:
+def inverted_schaffer_function_no4(x: Union[np.array, list]) -> float:
     """
     Inverted Schaffer function N. 4.
 
@@ -62,7 +68,8 @@ def inverted_schaffer_function_no4(x: list) -> float:
 
     The global maxima is at x [0, 1.253115] with value -0.292579
 
-    :param list x: A list of values. Values are evaluated between [-100, 100]
+    :param x: array or list of values. Values are evaluated between [-100, 100]
+    :type x: :class:`numpy.array` or list
     :return: The value of the Inverted Schaffer function N. 4.
     :rtype: float
     """

{mango-0.2.0 → mango-0.2.2}/mango/benchmark/optimization/schwefel.py

@@ -9,10 +9,10 @@ def schwefel(x: np.array) -> float:
 
     The global minima is located at [420,9687, ..., 420,9687] with a value of 0
 
-    :param :class:`np.array` x: input vector. The function is usually evaluated between [500, 500]
+    :param x: input vector. The function is usually evaluated between [500, 500]
+    :type x: :class:`numpy.array`
     :return: the value of the function
     :rtype: float
-    :doc-author: baobab soluciones
     """
     return 418.9829 * len(x) - np.sum(x * np.sin(np.sqrt(np.abs(x))))
 
@@ -26,9 +26,9 @@ def inverted_schwefel(x: np.array) -> float:
 
     The global minima is located at [420,9687, ..., 420,9687] with a value of 0
 
-    :param :class:`np.array` x: input vector. The function is usually evaluated between [500, 500]
+    :param x: input vector. The function is usually evaluated between [500, 500]
+    :type x: :class:`numpy.array`
     :return: the value of the function
     :rtype: float
-    :doc-author: baobab soluciones
     """
     return -schwefel(x)