Benchmark Functions

This module is an upgraded version of the Keita Tomochika’s module in https://github.com/keit0222/optimization-evaluation. The current module only contain N-dimensional functions. These functions are listed in __all__.

All these functions are based and revisited on the following research papers and websites:

• Momin Jamil and Xin-She Yang, A literature survey of benchmark functions for global optimization problems,

Int. Journal of Mathematical Modelling and Numerical Optimisation, Vol. 4, No. 2, pp. 150–194 (2013), arXiv:1308.4008 - Mazhar Ansari Ardeh, https://github.com/mazhar-ansari-ardeh, http://benchmarkfcns.xyz - Sonja Surjanovic and Derek Bingham, Simon Fraser University, https://www.sfu.ca/~ssurjano/optimization.html - Ali R. Al-Roomi (2015). Unconstrained Single-Objective Benchmark Functions Repository. Halifax, Nova Scotia, Canada, Dalhousie University, Electrical and Computer Engineering. https://www.al-roomi.org/benchmarks/unconstrained - B.Y. Qu, J.J. Liang, Z.Y. Wang, Q. Chen, P.N. Suganthan. Novel benchmark functions for continuous multimodal optimization with comparative results. Swarm and Evolutionary Computation, 26 (2016), 23-34.

Created on Tue Sep 17 14:29:43 2019

@author: Jorge Mario Cruz-Duarte (jcrvz.github.io), e-mail: j.m.cruzduarte@ieee.org

This module provides N-dimensional benchmark functions for continuous optimisation. Each function is implemented as a class inheriting from a common abstract base that exposes get_func_val, get_search_range, and get_optimal.

The catalogue covers classical test suites (Ackley, Rastrigin, Rosenbrock, Schwefel, Griewank, …) as well as the CEC 2005 competition suite when the optproblems package is available.

Quick usage:

from customhys import benchmark_func as bf

func = bf.Sphere(10)
print(func.get_func_val([0]*10))  # 0.0

class customhys.benchmark_func.Ackley1(variable_num)

Bases: BasicProblem

get_func_val(variables, a=20.0, b=0.2, c=6.283185307179586)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Ackley4(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Alpine1(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Alpine2(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Bohachevsky(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Brent(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Brown(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.CarromTable(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.ChungReynolds(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Cigar(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.CosineMixture(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.CrossInTray(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.CrossLegTable(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.CrownedCross(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Csendes(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Deb1(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Deb2(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.DeflectedCorrugatedSpring(variable_num)

Bases: BasicProblem

get_func_val(variables, alpha=5.0, k=5.0)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.DixonPrice(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.DropWave(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.EggHolder(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Ellipsoid(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.ExpandedDecreasingMinima(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.ExpandedEqualMinima(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.ExpandedFiveUnevenPeakTrap(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.ExpandedTwoPeakTrap(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.ExpandedUnevenMinima(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Exponential(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.F2(variable_num)

Bases: BasicProblem

l_values = [5.1, 0.5, 2.772588722239781, 0.066832364099628, 0.64]

get_func_val(variables, k=6.0, l_vals=None)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Giunta(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Griewank(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.HappyCat(variable_num)

Bases: BasicProblem

get_func_val(variables, alpha=0.125, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.HyperEllipsoid(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.InvertedCosineWave(variable_num)

Bases: BasicProblem

get_func_val(variables, k=6.0, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.JennrichSampson(variable_num)

Bases: BasicProblem

get_func_val(variables, d=10)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.KTablet(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Katsuura(variable_num)

Bases: BasicProblem

get_func_val(variables, d=32)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Levy(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.LunacekN01(variable_num)

Bases: BasicProblem

get_func_val(variables, mu1=2.5, d=1.0)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.LunacekN02(variable_num)

Bases: BasicProblem

get_func_val(variables, mu1=2.5, d=1.0)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Michalewicz(variable_num)

Bases: BasicProblem

approximated_optima = [2.2029, 1.5708, 1.285, 1.9231, 0.9967, 2.3988, 1.8772, 0.7885, 1.959, 1.217, 1.1604, 2.1268, 0.6188, 1.5708, 1.9023, 1.2419, 1.9426, 1.1709, 2.2214, 1.9238, 0.487, 1.9527, 1.2256, 1.1998, 1.9366, 0.7549, 1.9591, 2.7528, 0.7148, 1.9451, 1.197, 1.039, 1.9335, 0.3828, 2.6815, 1.5265, 1.2113, 1.9406, 1.1798, 2.3032, 1.8027, 0.7666, 2.1156, 0.749, 0.7406, 1.9377, 0.7247, 2.1026, 2.3103, 1.042, 1.9426, 1.4117, 0.9155, 2.3994, 0.301, 1.9466, 1.2826, 1.2027, 1.9401, 0.7588, 2.6833, 1.5708, 0.7405, 1.9438, 1.201, 1.1919, 1.9381, 0.4668, 1.9469, 2.0046, 1.0211, 1.9416, 1.1333, 2.0497, 1.7956, 0.4416, 2.0094, 1.2063, 1.1986, 1.9398, 0.7405, 2.1526, 2.4015, 0.6413, 1.9426, 1.0977, 1.1422, 1.9092, 0.2366, 2.3994, 1.0672, 1.2034, 1.941, 1.1906, 2.3131, 1.7996, 0.7481, 2.117, 1.2431, 1.1963]

get_func_val(variables, m=10.0)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Mishra1(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Mishra2(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Mishra7(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Mishra11(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.ModifiedVincent(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.NeedleEye(variable_num)

Bases: BasicProblem

get_func_val(variables, eye=0.0001, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Pathological(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Periodic(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Perm01(variable_num)

Bases: BasicProblem

get_func_val(variables, beta=1.0)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Perm02(variable_num)

Bases: BasicProblem

get_func_val(variables, beta=1.0)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Pinter(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.PowellSum(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Price01(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Qing(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Quartic(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Quintic(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Rana(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Rastrigin(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Ridge(variable_num)

Bases: BasicProblem

get_func_val(variables, d=2.0, alpha=0.1)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Rosenbrock(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.RotatedHyperEllipsoid(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Salomon(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Sargan(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.SchafferN1(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.SchafferN2(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.SchafferN3(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.SchafferN4(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.SchafferN6(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Schubert(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Schubert3(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Schubert4(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.SchumerSteiglitz(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Schwefel(variable_num)

Bases: BasicProblem

get_func_val(variables, alpha=0.5)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Schwefel12(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Schwefel204(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Schwefel220(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Schwefel221(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Schwefel222(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Schwefel223(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Schwefel225(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Schwefel226(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Sphere(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Step(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Step2(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Step3(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.StepInt(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Stochastic(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.StrechedVSineWave(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.StyblinskiTang(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.SumSquares(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Trid(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Trigonometric1(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Trigonometric2(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.TypeI(variable_num)

Bases: BasicProblem

get_func_val(variables, alpha=0.8, beta=1.0)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.TypeII(variable_num)

Bases: BasicProblem

get_func_val(variables, alpha=0.8, beta=1.0)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Vincent(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.WWavy(variable_num)

Bases: BasicProblem

get_func_val(variables, k=10.0, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Weierstrass(variable_num)

Bases: BasicProblem

get_func_val(variables, kmax=20, a=0.5, b=3.0, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Whitley(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.XinSheYang1(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.XinSheYang2(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.XinSheYang3(variable_num)

Bases: BasicProblem

get_func_val(variables, m=5.0, beta=15.0, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.XinSheYang4(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.YaoLiu09(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.Zakharov(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.ZeroSum(variable_num)

Bases: BasicProblem

get_func_val(variables, *args)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

class customhys.benchmark_func.CEC2005(f_name, variable_num, **kwargs)

Bases: BasicProblem

get_func_val(variables)

Evaluate the problem function without considering additions like noise, offset, etc. :param numpy.array variables:

The position where the problem function is going to be evaluated.

Parameters:

args – Additional arguments that some problem functions could consider.

Returns:

float

get_formatted_problem()

Return the problem in a simple format to be used in a solving procedure. This format contains the function in lambda form, the boundaries as a tuple with the lower and upper boundaries, and the is_constrained flag. :param bool is_constrained: Optional.

Flag indicating if the problem domain has hard boundaries.

Parameters:

fts (list) – Optional. List of features to be processed.

Returns:

dict.