Exemple #1
0
def test_mods235():
    # Schittkowski (modified) problem 235 (box/linearly constrained)
    def func(p):
        y = np.empty(2)
        y[0] = 0.1 * (p[0] - 1.0);
        y[1] = p[1] - p[0]*p[0];
        return y

    def jacf(p):
        j = np.empty((2, 3))
        j[0, 0] = 0.1
        j[0, 1] = 0.0
        j[0, 2] = 0.0
        j[1, 0] = -2.0 * p[0]
        j[1, 1] = 1.0
        j[1, 2] = 0.0
        return j

    y = np.zeros(2)
    p0 = [-2.000, 3.000, 1.000]
    pt = [-1.725, 2.900, 0.725]
    A = np.asarray([[1.0, 0.0, 1.0], [0.0, 1.0, -4.0]])
    b = np.asarray([-1.0, 0.0])
    bc = ((None, None), (0.1, 2.9), (0.7, None))

    p, pcov, info = levmar.levmar_blec(func, p0, y, bc, (A, b),
                                       jacf=jacf, **OPTS)
    assert_array_almost_equal(p, pt)
    p, pcov, info = levmar.levmar_blec(func, p0, y, bc, (A, b), **OPTS)
    assert_array_almost_equal(p, pt)
    p, pcov, info = levmar.levmar_blec(func, p0, y, bc, (A, b),
                                       cdiff=True, **OPTS)
    assert_array_almost_equal(p, pt)
Exemple #2
0
def test_mod1hs52():
    # Hock-Schittkowski (modified #1) problem 52 (box/linearly constrained)
    def func(p):
        y = np.empty(4)
        y[0] = 4.0 * p[0] - p[1]
        y[1] = p[1] + p[2] - 2.0
        y[2] = p[3] - 1.0
        y[3] = p[4] - 1.0
        return y

    def jacf(p):
        j = np.empty((4, 5))
        j[0, 0] = 4.0
        j[0, 1] = -1.0
        j[0, 2] = 0.0
        j[0, 3] = 0.0
        j[0, 4] = 0.0
        j[1, 0] = 0.0
        j[1, 1] = 1.0
        j[1, 2] = 1.0
        j[1, 3] = 0.0
        j[1, 4] = 0.0
        j[2, 0] = 0.0
        j[2, 1] = 0.0
        j[2, 2] = 0.0
        j[2, 3] = 1.0
        j[2, 4] = 0.0
        j[3, 0] = 0.0
        j[3, 1] = 0.0
        j[3, 2] = 0.0
        j[3, 3] = 0.0
        j[3, 4] = 1.0
        return j

    y = np.zeros(4)
    p0 = [2.0, 2.0, 2.0, 2.0, 2.0]
    pt = [-0.09, 0.03, 0.25, -0.19, 0.03]
    A = np.asarray([[1.0, 3.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 1.0, -2.0],
                    [0.0, 1.0, 0.0, 0.0, -1.0]])
    b = np.asarray([0.0, 0.0, 0.0])
    bc = [(-0.09, None), (0.0, 0.3), (None, 0.25), (-0.2, 0.3), (0.0, 0.3)]

    p, pcov, info = levmar.levmar_blec(func,
                                       p0,
                                       y,
                                       bc, (A, b),
                                       jacf=jacf,
                                       **OPTS)
    assert_array_almost_equal(p, pt)
    p, pcov, info = levmar.levmar_blec(func, p0, y, bc, (A, b), **OPTS)
    assert_array_almost_equal(p, pt)
    p, pcov, info = levmar.levmar_blec(func,
                                       p0,
                                       y,
                                       bc, (A, b),
                                       cdiff=True,
                                       **OPTS)
    assert_array_almost_equal(p, pt, decimal=3)
Exemple #3
0
def test_mod1hs52():
    # Hock-Schittkowski (modified #1) problem 52 (box/linearly constrained)
    def func(p):
        y = np.empty(4)
        y[0] = 4.0 * p[0] - p[1]
        y[1] = p[1] + p[2] - 2.0
        y[2] = p[3] - 1.0
        y[3] = p[4] - 1.0
        return y

    def jacf(p):
        j = np.empty((4, 5))
        j[0, 0] = 4.0
        j[0, 1] = -1.0
        j[0, 2] = 0.0
        j[0, 3] = 0.0
        j[0, 4] = 0.0
        j[1, 0] = 0.0
        j[1, 1] = 1.0
        j[1, 2] = 1.0
        j[1, 3] = 0.0
        j[1, 4] = 0.0
        j[2, 0] = 0.0
        j[2, 1] = 0.0
        j[2, 2] = 0.0
        j[2, 3] = 1.0
        j[2, 4] = 0.0
        j[3, 0] = 0.0
        j[3, 1] = 0.0
        j[3, 2] = 0.0
        j[3, 3] = 0.0
        j[3, 4] = 1.0
        return j

    y = np.zeros(4)
    p0 = [2.0, 2.0, 2.0, 2.0, 2.0]
    pt = [-0.09, 0.03, 0.25, -0.19, 0.03]
    A = np.asarray([[1.0, 3.0, 0.0, 0.0,  0.0],
                    [0.0, 0.0, 1.0, 1.0, -2.0],
                    [0.0, 1.0, 0.0, 0.0, -1.0]])
    b = np.asarray([0.0, 0.0, 0.0])
    bc = [(-0.09, None), (0.0, 0.3), (None, 0.25), (-0.2, 0.3), (0.0, 0.3)]

    p, pcov, info = levmar.levmar_blec(func, p0, y, bc, (A, b), jacf=jacf,
                                       **OPTS)
    assert_array_almost_equal(p, pt)
    p, pcov, info = levmar.levmar_blec(func, p0, y, bc, (A, b), **OPTS)
    assert_array_almost_equal(p, pt)
    p, pcov, info = levmar.levmar_blec(func, p0, y, bc, (A, b),
                                       cdiff=True, **OPTS)
    assert_array_almost_equal(p, pt, decimal=3)
Exemple #4
0
def test_modbt7():
    # Boggs and Tolle modified problem 7 (box/linearly constrained)
    def func(p):
        y = np.empty(5)
        t1 = p[1] - p[0] * p[0]
        t2 = p[0] - 1.0
        y[:] = 100.0 * t1 * t1 + t2 * t2
        return y

    def jacf(p):
        j = np.empty((5, 5))
        t = p[1] - p[0] * p[0]
        j[:, 0] = -400.0 * t * p[0] + 2.0 * p[0] - 2.0
        j[:, 1] = 200.0 * t
        j[:, 2] = 0.0
        j[:, 3] = 0.0
        j[:, 4] = 0.0
        return j

    y = np.zeros(5)
    p0 = [-2.00, 1.00, 1.00, 1.00, 1.00]
    pt = [0.70, 0.49, 0.19, 1.19, -0.20]
    A = np.asarray([[1.0, 1.0, -1.0, 0.0, 0.0], [1.0, 1.0, 0.0, -1.0, 0.0],
                    [1.0, 0.0, 0.0, 0.0, 1.0]])
    b = np.asarray([1.0, 0.0, 0.5])
    bc = [(None, 0.7), (None, None), (None, None), (None, None), (-0.3, None)]

    p, pcov, info = levmar.levmar_blec(func,
                                       p0,
                                       y,
                                       bc, (A, b),
                                       jacf=jacf,
                                       **OPTS)
    assert_array_almost_equal(p, pt)
    p, pcov, info = levmar.levmar_blec(func,
                                       p0,
                                       y,
                                       bc, (A, b),
                                       maxit=10000,
                                       **OPTS)
    assert_array_almost_equal(p, pt, decimal=3)
    p, pcov, info = levmar.levmar_blec(func,
                                       p0,
                                       y,
                                       bc, (A, b),
                                       maxit=10000,
                                       cdiff=True,
                                       **OPTS)
    assert_array_almost_equal(p, pt, decimal=4)
Exemple #5
0
def test_mods235():
    # Schittkowski (modified) problem 235 (box/linearly constrained)
    def func(p):
        y = np.empty(2)
        y[0] = 0.1 * (p[0] - 1.0)
        y[1] = p[1] - p[0] * p[0]
        return y

    def jacf(p):
        j = np.empty((2, 3))
        j[0, 0] = 0.1
        j[0, 1] = 0.0
        j[0, 2] = 0.0
        j[1, 0] = -2.0 * p[0]
        j[1, 1] = 1.0
        j[1, 2] = 0.0
        return j

    y = np.zeros(2)
    p0 = [-2.000, 3.000, 1.000]
    pt = [-1.725, 2.900, 0.725]
    A = np.asarray([[1.0, 0.0, 1.0], [0.0, 1.0, -4.0]])
    b = np.asarray([-1.0, 0.0])
    bc = ((None, None), (0.1, 2.9), (0.7, None))

    p, pcov, info = levmar.levmar_blec(func,
                                       p0,
                                       y,
                                       bc, (A, b),
                                       jacf=jacf,
                                       **OPTS)
    assert_array_almost_equal(p, pt)
    p, pcov, info = levmar.levmar_blec(func, p0, y, bc, (A, b), **OPTS)
    assert_array_almost_equal(p, pt)
    p, pcov, info = levmar.levmar_blec(func,
                                       p0,
                                       y,
                                       bc, (A, b),
                                       cdiff=True,
                                       **OPTS)
    assert_array_almost_equal(p, pt)
Exemple #6
0
def test_modbt7():
    # Boggs and Tolle modified problem 7 (box/linearly constrained)
    def func(p):
        y = np.empty(5)
        t1 = p[1] - p[0]*p[0]
        t2 = p[0] - 1.0
        y[:] = 100.0 * t1*t1 + t2*t2
        return y

    def jacf(p):
        j = np.empty((5, 5))
        t = p[1] - p[0]*p[0]
        j[:, 0] = -400.0 * t * p[0] + 2.0 * p[0] - 2.0
        j[:, 1] = 200.0 * t
        j[:, 2] = 0.0
        j[:, 3] = 0.0
        j[:, 4] = 0.0
        return j

    y = np.zeros(5)
    p0 = [-2.00, 1.00, 1.00, 1.00,  1.00]
    pt = [ 0.70, 0.49, 0.19, 1.19, -0.20]
    A = np.asarray([[1.0, 1.0, -1.0,  0.0, 0.0],
                    [1.0, 1.0,  0.0, -1.0, 0.0],
                    [1.0, 0.0,  0.0,  0.0, 1.0]])
    b = np.asarray([1.0, 0.0, 0.5])
    bc = [(None, 0.7), (None, None), (None, None), (None, None), (-0.3, None)]

    p, pcov, info = levmar.levmar_blec(func, p0, y, bc, (A, b),
                                       jacf=jacf, **OPTS)
    assert_array_almost_equal(p, pt)
    p, pcov, info = levmar.levmar_blec(func, p0, y, bc, (A, b),
                                       maxit=10000, **OPTS)
    assert_array_almost_equal(p, pt, decimal=3)
    p, pcov, info = levmar.levmar_blec(func, p0, y, bc, (A, b),
                                       maxit=10000, cdiff=True, **OPTS)
    assert_array_almost_equal(p, pt, decimal=4)