Python numpy.fmin() 使用实例

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'] 
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注