The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.
Example 1
def imin(arrays, axis, ignore_nan = False):
"""
Minimum of a stream of arrays along an axis.
Parameters
----------
arrays : iterable
Arrays to be reduced.
axis : int or None, optional
Axis along which the minimum is found. The default
is to find the minimum along the 'stream axis', as if all arrays in ``array``
were stacked along a new dimension. If ``axis = None``, arrays in ``arrays`` are flattened
before reduction.
ignore_nan : bool, optional
If True, NaNs are ignored. Default is propagation of NaNs.
Yields
------
online_min : ndarray
Cumulative minimum.
"""
ufunc = np.fmin if ignore_nan else np.minimum
yield from ireduce_ufunc(arrays, ufunc, axis) Example 2
def test_reduce(self):
dflt = np.typecodes['AllFloat']
dint = np.typecodes['AllInteger']
seq1 = np.arange(11)
seq2 = seq1[::-1]
func = np.fmin.reduce
for dt in dint:
tmp1 = seq1.astype(dt)
tmp2 = seq2.astype(dt)
assert_equal(func(tmp1), 0)
assert_equal(func(tmp2), 0)
for dt in dflt:
tmp1 = seq1.astype(dt)
tmp2 = seq2.astype(dt)
assert_equal(func(tmp1), 0)
assert_equal(func(tmp2), 0)
tmp1[::2] = np.nan
tmp2[::2] = np.nan
assert_equal(func(tmp1), 1)
assert_equal(func(tmp2), 1) Example 3
def test_reduce(self):
dflt = np.typecodes['AllFloat']
dint = np.typecodes['AllInteger']
seq1 = np.arange(11)
seq2 = seq1[::-1]
func = np.fmin.reduce
for dt in dint:
tmp1 = seq1.astype(dt)
tmp2 = seq2.astype(dt)
assert_equal(func(tmp1), 0)
assert_equal(func(tmp2), 0)
for dt in dflt:
tmp1 = seq1.astype(dt)
tmp2 = seq2.astype(dt)
assert_equal(func(tmp1), 0)
assert_equal(func(tmp2), 0)
tmp1[::2] = np.nan
tmp2[::2] = np.nan
assert_equal(func(tmp1), 1)
assert_equal(func(tmp2), 1) Example 4
def __init__(self, dim=3):
assert dim == 3
centers = numpy.array([
[.1, .8, .3],
])
e_mat = numpy.array([
[5, 5, 5],
])
coefs = numpy.array([-5])
def kernel(x):
r2 = self.dist_sq(x, centers, e_mat)
return numpy.exp(-r2)
super(McCourt14, self).__init__(dim, kernel, e_mat, coefs, centers)
self.min_loc = [.1, .8, .3]
self.fmin = -5
self.fmax = 0.00030641748
self.classifiers = ['boring', 'unimodal'] Example 5
def __init__(self, dim=3):
assert dim == 3
centers = numpy.array([
[.1, .8, .3],
])
e_mat = numpy.array([
[7, 7, 7],
])
coefs = numpy.array([-5])
def kernel(x):
r = numpy.sqrt(self.dist_sq(x, centers, e_mat))
return numpy.exp(-r)
super(McCourt15, self).__init__(dim, kernel, e_mat, coefs, centers)
self.min_loc = [.1, .8, .3]
self.fmin = -5
self.fmax = 0.00030641748
self.classifiers = ['boring', 'unimodal', 'nonsmooth'] Example 6
def __init__(self, dim=4):
assert dim == 4
centers = numpy.array([
[.3, .8, .3, .6],
[.4, .9, .4, .7],
])
e_mat = numpy.array([
[5, 5, 5, 5],
[5, 5, 5, 5],
])
coefs = numpy.array([-5, 5])
def kernel(x):
r2 = self.dist_sq(x, centers, e_mat)
return 1 / numpy.sqrt(1 + r2)
super(McCourt16, self).__init__(dim, kernel, e_mat, coefs, centers)
self.min_loc = [.1858, .6858, .1858, .4858]
self.fmin = -0.84221700966
self.fmax = 0.84132432380
self.classifiers = ['boring', 'unimodal'] Example 7
def __init__(self, dim=7):
assert dim == 7
centers = numpy.array([
[.3, .8, .3, .6, .2, .8, .5],
[.8, .3, .8, .2, .5, .2, .8],
[.2, .7, .2, .5, .4, .7, .3],
])
e_mat = numpy.array([
[4, 4, 4, 4, 4, 4, 4],
[4, 4, 4, 4, 4, 4, 4],
[4, 4, 4, 4, 4, 4, 4],
])
coefs = numpy.array([-5, 5, 5])
def kernel(x):
r2 = self.dist_sq(x, centers, e_mat)
return 1 / numpy.sqrt(1 + r2)
super(McCourt17, self).__init__(dim, kernel, e_mat, coefs, centers)
self.min_loc = [.3125, .9166, .3125, .7062, .0397, .9270, .5979]
self.fmin = -0.47089199032
self.fmax = 4.98733340158
self.classifiers = ['boring', 'unimodal'] Example 8
def __init__(self, dim=2):
full_min_loc_vec = [
2.202905513296628, 1.570796322320509, 1.284991564577549, 1.923058467505610,
1.720469766517768, 1.570796319218113, 1.454413962081172, 1.756086513575824,
1.655717409323190, 1.570796319387859, 1.497728796097675, 1.923739461688219,
]
full_fmin_vec = [
0.8013034100985499, 1, 0.9590912698958649, 0.9384624184720668,
0.9888010806214966, 1, 0.9932271353558245, 0.9828720362721659,
0.9963943649250527, 1, 0.9973305415507061, 0.9383447102236013,
]
assert dim <= len(full_min_loc_vec)
super(Michalewicz, self).__init__(dim)
self.bounds = lzip([0] * self.dim, [pi] * self.dim)
self.min_loc = full_min_loc_vec[:dim]
self.fmin = -sum(full_fmin_vec[:dim])
self.fmax = 0.0
self.classifiers = ['boring', 'complicated'] Example 9
def do_evaluate(self, x):
zh1 = (lambda v: 9 - v[0] - v[1])
zh2 = (lambda v: (v[0] - 3) ** 2 + (v[1] - 2) ** 2 - 16)
zh3 = (lambda v: v[0] * v[1] - 14)
zp = (lambda v: 100 * (1 + v))
px = [
zh1(x),
zp(zh2(x)) * sign(zh2(x)),
zp(zh3(x)) * sign(zh3(x)),
zp(-x[0]) * sign(x[0]),
zp(-x[1]) * sign(x[1])
]
return numpy.fmin(max(px), self.fmax)
# Below are all 1D functions Example 10
def test_reduce(self):
dflt = np.typecodes['AllFloat']
dint = np.typecodes['AllInteger']
seq1 = np.arange(11)
seq2 = seq1[::-1]
func = np.fmin.reduce
for dt in dint:
tmp1 = seq1.astype(dt)
tmp2 = seq2.astype(dt)
assert_equal(func(tmp1), 0)
assert_equal(func(tmp2), 0)
for dt in dflt:
tmp1 = seq1.astype(dt)
tmp2 = seq2.astype(dt)
assert_equal(func(tmp1), 0)
assert_equal(func(tmp2), 0)
tmp1[::2] = np.nan
tmp2[::2] = np.nan
assert_equal(func(tmp1), 1)
assert_equal(func(tmp2), 1) Example 11
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 12
def test_reduce(self):
dflt = np.typecodes['AllFloat']
dint = np.typecodes['AllInteger']
seq1 = np.arange(11)
seq2 = seq1[::-1]
func = np.fmin.reduce
for dt in dint:
tmp1 = seq1.astype(dt)
tmp2 = seq2.astype(dt)
assert_equal(func(tmp1), 0)
assert_equal(func(tmp2), 0)
for dt in dflt:
tmp1 = seq1.astype(dt)
tmp2 = seq2.astype(dt)
assert_equal(func(tmp1), 0)
assert_equal(func(tmp2), 0)
tmp1[::2] = np.nan
tmp2[::2] = np.nan
assert_equal(func(tmp1), 1)
assert_equal(func(tmp2), 1) Example 13
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 14
def test_reduce(self):
dflt = np.typecodes['AllFloat']
dint = np.typecodes['AllInteger']
seq1 = np.arange(11)
seq2 = seq1[::-1]
func = np.fmin.reduce
for dt in dint:
tmp1 = seq1.astype(dt)
tmp2 = seq2.astype(dt)
assert_equal(func(tmp1), 0)
assert_equal(func(tmp2), 0)
for dt in dflt:
tmp1 = seq1.astype(dt)
tmp2 = seq2.astype(dt)
assert_equal(func(tmp1), 0)
assert_equal(func(tmp2), 0)
tmp1[::2] = np.nan
tmp2[::2] = np.nan
assert_equal(func(tmp1), 1)
assert_equal(func(tmp2), 1) Example 15
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 16
def test_reduce(self):
dflt = np.typecodes['AllFloat']
dint = np.typecodes['AllInteger']
seq1 = np.arange(11)
seq2 = seq1[::-1]
func = np.fmin.reduce
for dt in dint:
tmp1 = seq1.astype(dt)
tmp2 = seq2.astype(dt)
assert_equal(func(tmp1), 0)
assert_equal(func(tmp2), 0)
for dt in dflt:
tmp1 = seq1.astype(dt)
tmp2 = seq2.astype(dt)
assert_equal(func(tmp1), 0)
assert_equal(func(tmp2), 0)
tmp1[::2] = np.nan
tmp2[::2] = np.nan
assert_equal(func(tmp1), 1)
assert_equal(func(tmp2), 1) Example 17
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 18
def sample_v_given_h(self, h, eps=1e-5):
mean_v = self.mean_v.eval(feed_dict={self.hidden: h})
if not self.beta_sampling:
rnds = np.random.randn(mean_v.shape[0], mean_v.shape[1]).astype(h.dtype)
return np.clip(mean_v + rnds * self.sigma, eps, 1. - eps)
mvvm = mean_v * (1 - mean_v)
var_v = np.fmin(mvvm, self.sigma**2)
operand = (mvvm + 1.5 * eps) / (var_v + eps) - 1
alpha = mean_v * operand + eps
beta = (1 - mean_v) * operand + eps
return np.random.beta(alpha, beta).astype(h.dtype) Example 19
def sample_h_given_v(self, v, eps=1e-5):
mean_h = self.mean_h.eval(feed_dict={self.visible: v})
if not self.beta_sampling:
rnds = np.random.randn(mean_h.shape[0], mean_h.shape[1]).astype(v.dtype)
return np.clip(mean_h + rnds * self.sigma, eps, 1. - eps)
mhhm = mean_h * (1 - mean_h)
# Handle the cases where h is close to 0.0 or 1.0
# Normally beta distribution will give a sample close to 0.0 or 1.0,
# breaking requirement that there be some variation (sample dispersion
# close to 0.0 when it ought to be close to self.sigma).
small_h = self.sigma**2 > mhhm
small_count = np.sum(small_h)
if small_count:
# We randomize these cases with probability self.sigma.
switch = np.random.rand(small_count) < self.sigma
if np.sum(switch):
mean_h[small_h][switch] = np.random.rand(np.sum(switch))
mhhm = mean_h * (1 - mean_h)
var_h = np.fmin(mhhm, self.sigma**2)
operand = (mhhm + 1.5 * eps) / (var_h + eps) - 1
alpha = mean_h * operand + eps
beta = (1 - mean_h) * operand + eps
return np.random.beta(alpha, beta).astype(v.dtype) Example 20
def test_reduce_complex(self):
assert_equal(np.fmin.reduce([1, 2j]), 2j)
assert_equal(np.fmin.reduce([1+3j, 2j]), 2j) Example 21
def test_float_nans(self):
nan = np.nan
arg1 = np.array([0, nan, nan])
arg2 = np.array([nan, 0, nan])
out = np.array([0, 0, nan])
assert_equal(np.fmin(arg1, arg2), out) Example 22
def test_complex_nans(self):
nan = np.nan
for cnan in [complex(nan, 0), complex(0, nan), complex(nan, nan)]:
arg1 = np.array([0, cnan, cnan], dtype=np.complex)
arg2 = np.array([cnan, 0, cnan], dtype=np.complex)
out = np.array([0, 0, nan], dtype=np.complex)
assert_equal(np.fmin(arg1, arg2), out) Example 23
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 24
def test_reduce_complex(self):
assert_equal(np.fmin.reduce([1, 2j]), 2j)
assert_equal(np.fmin.reduce([1+3j, 2j]), 2j) Example 25
def test_float_nans(self):
nan = np.nan
arg1 = np.array([0, nan, nan])
arg2 = np.array([nan, 0, nan])
out = np.array([0, 0, nan])
assert_equal(np.fmin(arg1, arg2), out) Example 26
def test_complex_nans(self):
nan = np.nan
for cnan in [complex(nan, 0), complex(0, nan), complex(nan, nan)]:
arg1 = np.array([0, cnan, cnan], dtype=np.complex)
arg2 = np.array([cnan, 0, cnan], dtype=np.complex)
out = np.array([0, 0, nan], dtype=np.complex)
assert_equal(np.fmin(arg1, arg2), out) Example 27
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 28
def __init__(self, dim, verify=True):
assert dim > 0
self.dim = dim
self.verify = verify
self.num_evals = 0
self.min_loc = None
self.fmin = None
self.local_fmin = []
self.fmax = None
self.bounds = None
self.classifiers = []
# Note(Mike) - Not using the records yet, but will be soon
self.records = None
self.reset_records() Example 29
def __init__(self, func, res, verify=True):
assert isinstance(func, TestFunction)
if res <= 0:
raise ValueError('Resolution level must be positive, level={0}'.format(res))
super(Discretizer, self).__init__(func.dim, verify)
self.bounds, self.min_loc = func.bounds, func.min_loc
self.res = res
self.fmax = numpy.floor(self.res * func.fmax) / self.res
self.fmin = numpy.floor(self.res * func.fmin) / self.res
self.func = func
self.classifiers = list(set(self.classifiers) | set(['discrete'])) Example 30
def __init__(self, func, fail_indicator, return_nan=True, verify=True):
assert isinstance(func, TestFunction)
super(Failifier, self).__init__(func.dim, verify)
self.bounds, self.min_loc, self.fmax, self.fmin = func.bounds, func.min_loc, func.fmax, func.fmin
self.func = func
self.fail_indicator = fail_indicator
self.return_nan = return_nan
self.classifiers = list(set(self.classifiers) | set(['failure'])) Example 31
def __init__(self, func, constraint_weights, constraint_rhs, constraint_check=None, return_nan=True, verify=True):
assert isinstance(func, TestFunction)
assert len(constraint_weights) == len(constraint_rhs)
super(Constrainer, self).__init__(func.dim, verify)
self.bounds, self.min_loc, self.fmax, self.fmin = func.bounds, func.min_loc, func.fmax, func.fmin
self.func = func
self.constraint_weights = constraint_weights
self.constraint_rhs = constraint_rhs
self.return_nan = return_nan
self.classifiers = list(set(self.classifiers) | set(['constraint']))
if constraint_check is not None:
self.constraint_check = constraint_check
else:
self.constraint_check = Constrainer.default_constraint_check Example 32
def __init__(self, func, noise_type, level, verify=True):
assert isinstance(func, TestFunction)
if level <= 0:
raise ValueError('Noise level must be positive, level={0}'.format(level))
super(Noisifier, self).__init__(func.dim, verify)
self.bounds, self.min_loc, self.fmax, self.fmin = func.bounds, func.min_loc, func.fmax, func.fmin
self.type = noise_type
self.level = level
self.func = func
self.classifiers = list(set(self.classifiers) | set(['noisy'])) Example 33
def __init__(self, dim=2):
assert dim == 2
super(Adjiman, self).__init__(dim)
self.bounds = ([-1, 2], [-1, 1])
self.min_loc = [2, 0.10578]
self.fmin = -2.02180678
self.fmax = 1.07715029333
self.classifiers = ['unimodal', 'bound_min'] Example 34
def __init__(self, dim=2):
super(Alpine01, self).__init__(dim)
self.bounds = lzip([-6] * self.dim, [10] * self.dim)
self.min_loc = [0] * self.dim
self.fmin = 0
self.fmax = 8.71520568065 * self.dim
self.classifiers = ['nonsmooth'] Example 35
def __init__(self, dim=2):
assert dim == 2
super(Alpine02, self).__init__(dim)
self.bounds = lzip([0] * self.dim, [10] * self.dim)
self.min_loc = [7.91705268, 4.81584232]
self.fmin = -6.12950389113
self.fmax = 7.88560072413
self.classifiers = ['oscillatory', 'multi_min'] Example 36
def __init__(self, dim=2):
super(ArithmeticGeometricMean, self).__init__(dim)
self.bounds = lzip([0] * self.dim, [10] * self.dim)
self.min_loc = [0] * self.dim
self.fmin = 0
self.fmax = (10 * (self.dim - 1.0) / self.dim) ** 2
self.classifiers = ['bound_min', 'boring', 'multi_min'] Example 37
def __init__(self, dim=2):
assert dim == 2
super(BartelsConn, self).__init__(dim)
self.bounds = lzip([-2] * self.dim, [5] * self.dim)
self.min_loc = [0] * self.dim
self.fmin = 1
self.fmax = 76.2425864601
self.classifiers = ['nonsmooth', 'unimodal'] Example 38
def __init__(self, dim=2):
assert dim == 2
super(Bird, self).__init__(dim)
self.bounds = lzip([-2 * pi] * self.dim, [2 * pi] * self.dim)
self.min_loc = [4.701055751981055, 3.152946019601391]
self.fmin = -64.60664462282
self.fmax = 160.63195224589
self.classifiers = ['multi_min'] Example 39
def __init__(self, dim=2):
assert dim == 2
super(Bohachevsky, self).__init__(dim)
self.bounds = lzip([-15] * self.dim, [8] * self.dim)
self.min_loc = [0] * self.dim
self.fmin = 0
self.fmax = 675.6
self.classifiers = ['oscillatory'] Example 40
def __init__(self, dim=3):
assert dim == 3
super(BoxBetts, self).__init__(dim)
self.bounds = ([0.9, 1.2], [9, 11.2], [0.9, 1.2])
self.min_loc = [1, 10, 1]
self.fmin = 0
self.fmax = 0.28964792415
self.classifiers = ['boring'] Example 41
def __init__(self, dim=2):
assert dim == 2
super(Branin01, self).__init__(dim)
self.bounds = [[-5, 10], [0, 15]]
self.min_loc = [-pi, 12.275]
self.fmin = 0.39788735772973816
self.fmax = 308.129096012
self.classifiers = ['multi_min'] Example 42
def __init__(self, dim=2):
assert dim == 2
super(Branin02, self).__init__(dim)
self.bounds = [(-5, 15), (-5, 15)]
self.min_loc = [-3.2, 12.53]
self.fmin = 5.559037
self.fmax = 506.983390872 Example 43
def __init__(self, dim=2):
assert dim > 1
super(Brown, self).__init__(dim)
self.bounds = lzip([-1] * self.dim, [2] * self.dim)
self.min_loc = [0] * self.dim
self.fmin = 0
self.fmax = self.do_evaluate(numpy.array([2] * self.dim))
self.classifiers = ['unimodal', 'unscaled'] Example 44
def __init__(self, dim=2):
assert dim == 2
super(Bukin06, self).__init__(dim)
self.bounds = [(-15, -5), (-3, 3)]
self.min_loc = [-10, 1]
self.fmin = 0
self.fmax = 229.178784748
self.classifiers = ['nonsmooth'] Example 45
def __init__(self, dim=2):
assert dim == 2
super(CarromTable, self).__init__(dim)
self.bounds = lzip([-10] * self.dim, [10] * self.dim)
self.min_loc = [9.646157266348881, 9.646134286497169]
self.fmin = -24.15681551650653
self.fmax = 0
self.classifiers = ['boring', 'multi_min', 'nonsmooth', 'complicated'] Example 46
def __init__(self, dim=2):
assert dim == 2
super(Chichinadze, self).__init__(dim)
self.bounds = lzip([-30] * self.dim, [30] * self.dim)
self.min_loc = [6.189866586965680, 0.5]
self.fmin = -42.94438701899098
self.fmax = 1261
self.classifiers = ['oscillatory'] Example 47
def __init__(self, dim=2):
assert dim > 1
super(Cigar, self).__init__(dim)
self.bounds = lzip([-1] * self.dim, [1] * self.dim)
self.min_loc = [0] * self.dim
self.fmin = 0
self.fmax = 1 + 1e6 * self.dim
self.classifiers = ['unimodal', 'unscaled'] Example 48
def __init__(self, dim=4):
assert dim == 4
super(Corana, self).__init__(dim)
self.bounds = lzip([-5] * self.dim, [5] * self.dim)
self.min_loc = [0] * self.dim
self.fglob = 0
self.fmin = 0
self.fmax = 24999.3261012
self.classifiers = ['boring', 'unscaled', 'nonsmooth'] Example 49
def __init__(self, dim=2):
super(CosineMixture, self).__init__(dim)
self.bounds = lzip([-1] * self.dim, [1] * self.dim)
self.min_loc = [0.184872823182918] * self.dim
self.fmin = -0.063012202176250 * self.dim
self.fmax = 0.9 * self.dim
self.classifiers = ['oscillatory', 'multi_min'] Example 50
def __init__(self, dim=2):
assert dim == 2
super(CrossInTray, self).__init__(dim)
self.bounds = lzip([-10] * self.dim, [10] * self.dim)
self.min_loc = [1.349406685353340, 1.349406608602084]
self.fmin = -2.062611870822739
self.fmax = -0.25801263059
self.classifiers = ['oscillatory', 'multi_min', 'nonsmooth', 'complicated'] 