def test_hs01():
# Hock-Schittkowski problem 01 (box constrained)
def func(p):
y = np.empty(2)
y[0] = 10.0 * (p[1] - p[0]*p[0])
y[1] = 1.0 - p[0]
return y
def jacf(p):
j = np.empty((2, 2))
j[0, 0] = -20.0 * p[0]
j[0, 1] = 10.0
j[1, 0] = -1.0
j[1, 1] = 0.0
return j
y = np.zeros(2)
p0 = [-2.0, 1.0]
pt = [ 1.0, 1.0]
bc = [(None, None), (-1.5, None)]
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, jacf=jacf, **OPTS)
assert_array_almost_equal(p, pt)
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, **OPTS)
assert_array_almost_equal(p, pt)
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, cdiff=True, **OPTS)
assert_array_almost_equal(p, pt)
def test_hs21():
# Hock-Schittkowski MODIFIED problem 21 (box constrained)
def func(p):
y = np.empty(2)
y[0] = p[0] / 10.0
y[1] = p[1]
return y
def jacf(p):
j = np.empty((2, 2))
j[0, 0] = 0.1
j[0, 1] = 0.0
j[1, 0] = 0.0
j[1, 1] = 1.0
return j
y = np.zeros(2)
p0 = [-1.0, -1.0]
pt = [ 2.0, 0.0]
bc = [(2.0, 50.0), (-50.0, 50.0)]
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, jacf=jacf, **OPTS)
assert_array_almost_equal(p, pt)
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, **OPTS)
assert_array_almost_equal(p, pt)
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, cdiff=True, **OPTS)
assert_array_almost_equal(p, pt)
def test_hs21():
# Hock-Schittkowski MODIFIED problem 21 (box constrained)
def func(p):
y = np.empty(2)
y[0] = p[0] / 10.0
y[1] = p[1]
return y
def jacf(p):
j = np.empty((2, 2))
j[0, 0] = 0.1
j[0, 1] = 0.0
j[1, 0] = 0.0
j[1, 1] = 1.0
return j
y = np.zeros(2)
p0 = [-1.0, -1.0]
pt = [2.0, 0.0]
bc = [(2.0, 50.0), (-50.0, 50.0)]
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, jacf=jacf, **OPTS)
assert_array_almost_equal(p, pt)
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, **OPTS)
assert_array_almost_equal(p, pt)
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, cdiff=True, **OPTS)
assert_array_almost_equal(p, pt)
def test_hs01():
# Hock-Schittkowski problem 01 (box constrained)
def func(p):
y = np.empty(2)
y[0] = 10.0 * (p[1] - p[0] * p[0])
y[1] = 1.0 - p[0]
return y
def jacf(p):
j = np.empty((2, 2))
j[0, 0] = -20.0 * p[0]
j[0, 1] = 10.0
j[1, 0] = -1.0
j[1, 1] = 0.0
return j
y = np.zeros(2)
p0 = [-2.0, 1.0]
pt = [1.0, 1.0]
bc = [(None, None), (-1.5, None)]
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, jacf=jacf, **OPTS)
assert_array_almost_equal(p, pt)
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, **OPTS)
assert_array_almost_equal(p, pt)
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, cdiff=True, **OPTS)
assert_array_almost_equal(p, pt)
def test_hatfldc():
# Problem hatfldc (box constrained)
def func(p):
y = np.empty(4)
y[0] = p[0] - 1.0
for i in range(1, 3):
y[i] = p[i-1] - sqrt(p[i])
y[3] = p[3] - 1.0
return y
def jacf(p):
j = np.empty((4, 4))
j[0, 0] = 1.0
j[0, 1] = 0.0
j[0, 2] = 0.0
j[0, 3] = 0.0
j[1, 0] = 1.0
j[1, 1] = -0.5 / sqrt(p[1])
j[1, 2] = 0.0
j[1, 3] = 0.0
j[2, 0] = 0.0
j[2, 1] = 1.0
j[2, 2] = -0.5 / sqrt(p[2])
j[2, 3] = 0.0
j[3, 0] = 0.0
j[3, 1] = 0.0
j[3, 2] = 0.0
j[3, 3] = 1.0
return j
y = np.zeros(4)
p0 = [0.9, 0.9, 0.9, 0.9]
pt = [1.0, 1.0, 1.0, 1.0]
bc = [(0.0, 10.0), (0.0, 10.0), (0.0, 10.0), (0.0, 10.0)]
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, jacf=jacf, **OPTS)
assert_array_almost_equal(p, pt)
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, **OPTS)
assert_array_almost_equal(p, pt)
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, cdiff=True, **OPTS)
assert_array_almost_equal(p, pt)
def test_hatfldc():
# Problem hatfldc (box constrained)
def func(p):
y = np.empty(4)
y[0] = p[0] - 1.0
for i in range(1, 3):
y[i] = p[i - 1] - sqrt(p[i])
y[3] = p[3] - 1.0
return y
def jacf(p):
j = np.empty((4, 4))
j[0, 0] = 1.0
j[0, 1] = 0.0
j[0, 2] = 0.0
j[0, 3] = 0.0
j[1, 0] = 1.0
j[1, 1] = -0.5 / sqrt(p[1])
j[1, 2] = 0.0
j[1, 3] = 0.0
j[2, 0] = 0.0
j[2, 1] = 1.0
j[2, 2] = -0.5 / sqrt(p[2])
j[2, 3] = 0.0
j[3, 0] = 0.0
j[3, 1] = 0.0
j[3, 2] = 0.0
j[3, 3] = 1.0
return j
y = np.zeros(4)
p0 = [0.9, 0.9, 0.9, 0.9]
pt = [1.0, 1.0, 1.0, 1.0]
bc = [(0.0, 10.0), (0.0, 10.0), (0.0, 10.0), (0.0, 10.0)]
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, jacf=jacf, **OPTS)
assert_array_almost_equal(p, pt)
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, **OPTS)
assert_array_almost_equal(p, pt)
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, cdiff=True, **OPTS)
assert_array_almost_equal(p, pt)
def test_combust():
# Equilibrium combustion problem, constrained nonlinear equation from the
# book by Floudas et al.
R = 10.0
R5 = 0.193
R6 = 4.10622*1e-4
R7 = 5.45177*1e-4
R8 = 4.4975*1e-7
R9 = 3.40735*1e-5
R10 = 9.615*1e-7
def func(p):
p0, p1, p2, p3, p4 = p
y = np.empty(5)
y[0] = p0 * p1 + p0 - 3.0 * p4
y[1] = 2.0 * p0 * p1 + p0 + 3.0 * R10 * p1*p1 + p1 * p2*p2 + \
R7 * p1 * p2 + R9 * p1 * p3 + R8 * p1 - R * p4
y[2] = 2.0 * p1 * p2*p2 + R7 * p1 * p2 + 2.0 * R5 * p2*p2 + \
R6 * p2 - 8.0*p4
y[3] = R9 * p1 * p3 + 2.0 * p3*p3 - 4.0 * R * p4
y[4] = p0 * p1 + p0 + R10 * p1*p1 + p1 * p2*p2 + \
R7 * p1 * p2 + R9 * p1 * p3 + R8 * p1 + R5 * p2*p2 + \
R6 * p2 + p3*p3 - 1.0
return y
def jacf(p):
p0, p1, p2, p3, p4 = p
j = np.empty((5, 5))
j[0, 0] = p1 + 1.0
j[0, 1] = p0
j[0, 2] = 0.0
j[0, 3] = 0.0
j[0, 4] = -3.0
j[1, 0] = 2.0 * p1 + 1.0
j[1, 1] = 2.0 * p0 + 6.0 * R10 * p1 + p2*p2 + R7 * p2 + R9 * p3 + R8
j[1, 2] = 2.0 * p1 * p2 + R7 * p1
j[1, 3] = R9*p1
j[1, 4] = -R
j[2, 0] = 0.0
j[2, 1] = 2.0 * p2*p2 + R7 * p2
j[2, 2] = 4.0 * p1 * p2 + R7 * p1 + 4 * R5 * p2 + R6
j[2, 3] = -8.0
j[2, 4] = 0.0
j[3, 0] = 0.0
j[3, 1] = R9 * p3
j[3, 2] = 0.0
j[3, 3] = R9 * p1 + 4.0*p3
j[3, 4] = -4.0 * R
j[4, 0] = p1 + 1.0
j[4, 1] = p0 + 2.0 * R10 * p1 + p2*p2 + R7 * p2 + R9 * p3 + R8
j[4, 2] = 2.0 * p1 * p2 + R7 * p1 + 2.0 * R5 * p2 + R6
j[4, 3] = R9 * p1 + 2.0 * p3
j[4, 4] = 0
return j
y = np.zeros(5)
p0 = [0.0010, 0.0010, 0.0010, 0.0010, 0.0010]
pt = [0.0034, 31.3265, 0.0684, 0.8595, 0.0370]
bc = [(0.001, 100), (0.001, 100), (0.001, 100), (0.001, 100), (0.001, 100)]
p, pcov, info = levmar.levmar_bc(func, p0, y, bc, jacf=jacf,
maxit=5000, **OPTS)
assert_array_almost_equal(p, pt, decimal=1)
import numpy as np
import levmar
np.random.seed(1234)
def gauss(p, x):
return p[0] * np.exp(-4 * log(2) * ((x - p[1]) / p[2])**2) + p[3]
# Create input data
x_mea = np.linspace(-5, 5)
p_tru = [230, -0.4, 2.0, 0.1]
y_tru = gauss(p_tru, x_mea)
y_mea = y_tru + np.sqrt(y_tru) * np.random.randn(x_mea.size)
# Initial estimate
p_ini = [1.0, -3.0, 3.0, 1.0]
# Ensure the width is (0, Inf).
bc = [(None, None), (None, None), (1.0e-6, None), (-10.0, 10.0)]
# Run the fitting routine
p_opt, p_cov, info = levmar.levmar_bc(gauss, p_ini, y_mea, bc, args=(x_mea,))
# Print the result
print("Expected:")
print(" {0[0]:9f} {0[1]:9f} {0[2]:9f}".format(p_tru))
print("Estimate:")
print(" {0[0]:9f} {0[1]:9f} {0[2]:9f}".format(p_opt))
print("")
def test_combust():
# Equilibrium combustion problem, constrained nonlinear equation from the
# book by Floudas et al.
R = 10.0
R5 = 0.193
R6 = 4.10622 * 1e-4
R7 = 5.45177 * 1e-4
R8 = 4.4975 * 1e-7
R9 = 3.40735 * 1e-5
R10 = 9.615 * 1e-7
def func(p):
p0, p1, p2, p3, p4 = p
y = np.empty(5)
y[0] = p0 * p1 + p0 - 3.0 * p4
y[1] = 2.0 * p0 * p1 + p0 + 3.0 * R10 * p1*p1 + p1 * p2*p2 + \
R7 * p1 * p2 + R9 * p1 * p3 + R8 * p1 - R * p4
y[2] = 2.0 * p1 * p2*p2 + R7 * p1 * p2 + 2.0 * R5 * p2*p2 + \
R6 * p2 - 8.0*p4
y[3] = R9 * p1 * p3 + 2.0 * p3 * p3 - 4.0 * R * p4
y[4] = p0 * p1 + p0 + R10 * p1*p1 + p1 * p2*p2 + \
R7 * p1 * p2 + R9 * p1 * p3 + R8 * p1 + R5 * p2*p2 + \
R6 * p2 + p3*p3 - 1.0
return y
def jacf(p):
p0, p1, p2, p3, p4 = p
j = np.empty((5, 5))
j[0, 0] = p1 + 1.0
j[0, 1] = p0
j[0, 2] = 0.0
j[0, 3] = 0.0
j[0, 4] = -3.0
j[1, 0] = 2.0 * p1 + 1.0
j[1, 1] = 2.0 * p0 + 6.0 * R10 * p1 + p2 * p2 + R7 * p2 + R9 * p3 + R8
j[1, 2] = 2.0 * p1 * p2 + R7 * p1
j[1, 3] = R9 * p1
j[1, 4] = -R
j[2, 0] = 0.0
j[2, 1] = 2.0 * p2 * p2 + R7 * p2
j[2, 2] = 4.0 * p1 * p2 + R7 * p1 + 4 * R5 * p2 + R6
j[2, 3] = -8.0
j[2, 4] = 0.0
j[3, 0] = 0.0
j[3, 1] = R9 * p3
j[3, 2] = 0.0
j[3, 3] = R9 * p1 + 4.0 * p3
j[3, 4] = -4.0 * R
j[4, 0] = p1 + 1.0
j[4, 1] = p0 + 2.0 * R10 * p1 + p2 * p2 + R7 * p2 + R9 * p3 + R8
j[4, 2] = 2.0 * p1 * p2 + R7 * p1 + 2.0 * R5 * p2 + R6
j[4, 3] = R9 * p1 + 2.0 * p3
j[4, 4] = 0
return j
y = np.zeros(5)
p0 = [0.0010, 0.0010, 0.0010, 0.0010, 0.0010]
pt = [0.0034, 31.3265, 0.0684, 0.8595, 0.0370]
bc = [(0.001, 100), (0.001, 100), (0.001, 100), (0.001, 100), (0.001, 100)]
p, pcov, info = levmar.levmar_bc(func,
p0,
y,
bc,
jacf=jacf,
maxit=5000,
**OPTS)
assert_array_almost_equal(p, pt, decimal=1)
