def test_minos_single_with_gradient():
m = Minuit(func3, grad_fcn=func3_grad, pedantic=False, print_level=0)
m.set_strategy(2)
m.migrad()
m.minos('x')
assert_allclose(m.merrors[('x', -1.0)], -sqrt(5))
assert_allclose(m.merrors[('x', 1.0)], sqrt(5))
def test_initial_value():
m = Minuit(func3, pedantic=False, x=1., y=2., error_x=3., print_level=0)
assert_allclose(m.args[0], 1.)
assert_allclose(m.args[1], 2.)
assert_allclose(m.values['x'], 1.)
assert_allclose(m.values['y'], 2.)
assert_allclose(m.errors['x'], 3.)
def test_beale():
random.seed(0.258)
m = Minuit(beale, x=random.random(), y=0.5 * random.random(),
pedantic=False, print_level=0)
m.tol = 1e-4
m.migrad()
assert_allclose(m.fval, 0, atol=1e-6)
assert_allclose(m.args, [3, 0.5], atol=1e-3)
assert m.fval < 1e-6
def test_matyas():
random.seed(0.258)
m = Minuit(matyas, x=random.random(), y=random.random(),
pedantic=False, print_level=0)
m.tol = 1e-4
m.migrad()
assert m.fval < 1e-26
assert_allclose(m.args, [0, 0], atol=1e-12)
def test_matyas_oneside():
"""One-sided limit when the minimum is in the forbidden region"""
random.seed(0.258)
m = Minuit(matyas, x=2 + random.random(), y=random.random(),
limit_x=(1, None),
pedantic=False, print_level=0)
m.tol = 1e-4
m.migrad()
assert_allclose(m.args, [1, 0.923], atol=1e-3)
def test_oneside():
m_limit = Minuit(func3, limit_x=(None, 9), pedantic=False, print_level=0)
m_nolimit = Minuit(func3, pedantic=False, print_level=0)
# Solution: x=2., y=5.
m_limit.tol = 1e-4
m_nolimit.tol = 1e-4
m_limit.migrad()
m_nolimit.migrad()
assert_allclose(list(m_limit.values.values()),
list(m_nolimit.values.values()), atol=1e-4)
def test_chi2_fit():
"""Fit a curve to data."""
m = Minuit(chi2, s=2., error_A=0.1, errordef=0.01,
print_level=0, pedantic=False)
m.migrad()
output = [round(10 * m.values['A']), round(100 * m.values['s']),
round(100 * m.values['m'])]
expected = [round(10 * 64.375993), round(100 * 4.267970),
round(100 * 9.839172)]
assert_allclose(output, expected)
def test_ackleys():
random.seed(0.258)
m = Minuit(ackleys, x=1.5 * random.random(), y=1.5 * random.random(),
error_x=1.7, error_y=1.7,
pedantic=False, print_level=0)
m.tol = 1e-4
m.migrad()
assert_allclose(m.fval, 0, atol=1e-6)
assert_allclose(m.args, [0, 0], atol=1e-6)
def test_callback():
trace = []
result = minimize(func, np.ones(3),
callback=lambda x: trace.append(x.copy()))
assert_allclose(result.x, (0, 1, 2), atol=1e-8)
assert_allclose(result.fun, 1)
assert result.nfev == len(trace)
assert_allclose(trace[0], np.ones(3), atol=1e-2)
assert_allclose(trace[-1], result.x, atol=1e-2)
def test_mncontour_sigma():
m = Minuit(func3, pedantic=False, x=1., y=2., error_x=3., print_level=0)
m.migrad()
xminos, yminos, ctr = m.mncontour('x', 'y', numpoints=30, sigma=2.0)
xminos_t = m.minos('x', sigma=2.0)['x']
yminos_t = m.minos('y', sigma=2.0)['y']
assert_allclose(xminos.upper, xminos_t.upper)
assert_allclose(xminos.lower, xminos_t.lower)
assert_allclose(yminos.upper, yminos_t.upper)
assert_allclose(yminos.lower, yminos_t.lower)
assert len(ctr) == 30
assert len(ctr[0]) == 2
def test_array_call():
inf = float("infinity")
m = Minuit(func8,
a=1,
b=1,
error_a=1,
error_b=1,
limit_a=(0, inf),
limit_b=(0, inf),
fix_a=False,
fix_b=False,
print_level=0,
errordef=1,
use_array_call=True,
forced_parameters=("a", "b"))
m.migrad()
v = m.values
assert_allclose((v["a"], v["b"]), (1, 1))
m.hesse()
c = m.covariance
assert_allclose((c[("a", "a")], c[("b", "b")]), (1, 1))
def test_from_array_func_with_broadcasting():
m = Minuit.from_array_func(func8, (1, 1),
error=0.5,
limit=(0, 2),
errordef=1,
print_level=0)
assert m.fitarg == {
"x0": 1,
"x1": 1,
"error_x0": 0.5,
"error_x1": 0.5,
"fix_x0": False,
"fix_x1": False,
"limit_x0": (0, 2),
"limit_x1": (0, 2)
}
m.migrad()
v = m.np_values()
assert_allclose(v, (1, 1))
c = m.np_covariance()
assert_allclose(np.diag(c), (1, 1))
def test_minos_all():
m = Minuit(func3, pedantic=False, print_level=0)
m.migrad()
m.minos()
assert_allclose(m.merrors[('x', -1.0)], -sqrt(5))
assert_allclose(m.merrors[('x', 1.0)], sqrt(5))
assert_allclose(m.merrors[('y', 1.0)], 1.)
def test_minos_all():
m = Minuit(func3, pedantic=False, print_level=0)
m.migrad()
m.minos()
assert_allclose(m.merrors[('x', -1.0)], -sqrt(5))
assert_allclose(m.merrors[('x', 1.0)], sqrt(5))
assert_allclose(m.merrors[('y', 1.0)], 1.)
def test_mncontour_array_func():
m = Minuit.from_array_func(
Func9(), (0, 0), name=("x", "y"), pedantic=False, print_level=0
)
m.migrad()
xminos, yminos, ctr = m.mncontour("x", "y", numpoints=30, sigma=1)
xminos_t = m.minos("x", sigma=1)["x"]
yminos_t = m.minos("y", sigma=1)["y"]
assert_allclose(xminos.upper, xminos_t.upper)
assert_allclose(xminos.lower, xminos_t.lower)
assert_allclose(yminos.upper, yminos_t.upper)
assert_allclose(yminos.lower, yminos_t.lower)
assert len(ctr) == 30
assert len(ctr[0]) == 2
def test_minos_all(grad, sigma):
m = Minuit(func3, grad=func3_grad, pedantic=False, print_level=0)
m.migrad()
m.minos(sigma=sigma)
assert_allclose(m.merrors[('x', -1.0)], -sigma * 2, rtol=1e-2)
assert_allclose(m.merrors[('x', 1.0)], sigma * 2, rtol=1e-2)
assert_allclose(m.merrors[('y', 1.0)], sigma * 1, rtol=1e-2)
def test_mncontour(grad, sigma):
m = Minuit(
func3, grad=grad, pedantic=False, x=1.0, y=2.0, error_x=3.0, print_level=0
)
m.migrad()
xminos, yminos, ctr = m.mncontour("x", "y", numpoints=30, sigma=sigma)
xminos_t = m.minos("x", sigma=sigma)["x"]
yminos_t = m.minos("y", sigma=sigma)["y"]
assert_allclose(xminos.upper, xminos_t.upper)
assert_allclose(xminos.lower, xminos_t.lower)
assert_allclose(yminos.upper, yminos_t.upper)
assert_allclose(yminos.lower, yminos_t.lower)
assert len(ctr) == 30
assert len(ctr[0]) == 2
def test_rosenbrock():
m = Minuit(rosenbrock, x=0, y=0, pedantic=False, print_level=1)
m.tol = 1e-4
m.migrad()
assert_allclose(m.fval, 0, atol=1e-6)
assert_allclose(m.values['x'], 1., atol=1e-3)
assert_allclose(m.values['y'], 1., atol=1e-3)
def test_minos_all_with_gradient():
m = Minuit(func3, grad_fcn=func3_grad, pedantic=False, print_level=0)
m.set_strategy(2)
m.migrad()
m.minos()
assert_allclose(m.merrors[('x', -1.0)], -sqrt(5))
assert_allclose(m.merrors[('x', 1.0)], sqrt(5))
assert_allclose(m.merrors[('y', 1.0)], 1.)
def m():
m = Minuit(f1, x=0, y=0, pedantic=False, print_level=1)
m.tol = 1e-4
m.migrad()
assert_allclose(m.fval, 0, atol=1e-6)
assert_allclose(m.values['x'], 1, atol=1e-3)
assert_allclose(m.values['y'], 1, atol=1e-3)
return m
def m():
m = Minuit(f1, x=0, y=0, pedantic=False, print_level=1)
m.tol = 1e-4
m.migrad()
assert_allclose(m.fval, 0, atol=1e-6)
assert_allclose(m.values['x'], 1, atol=1e-3)
assert_allclose(m.values['y'], 1, atol=1e-3)
return m
def test_rosenbrock():
random.seed(0.258)
m = Minuit(rosenbrock, x=0, y=0, pedantic=False, print_level=1)
m.tol = 1e-4
m.migrad()
assert_allclose(m.fval, 0, atol=1e-6)
assert_allclose(m.values['x'], 1., atol=1e-3)
assert_allclose(m.values['y'], 1., atol=1e-3)
def test_get_param_states():
m = Minuit(
func3,
x=1,
y=2,
error_x=3,
error_y=4,
fix_x=True,
limit_y=(None, 10),
pedantic=False,
errordef=1,
print_level=0,
)
# these are the initial param states
expected = [
Param(0, "x", 1.0, 3.0, False, True, False, False, False, None, None),
Param(1, "y", 2.0, 4.0, False, False, True, False, True, None, 10),
]
assert m.get_param_states() == expected
m.migrad()
assert m.get_initial_param_states() == expected
expected = [
Param(0, "x", 1.0, 3.0, False, True, False, False, False, None, None),
Param(1, "y", 5.0, 1.0, False, False, True, False, True, None, 10),
]
params = m.get_param_states()
for i, exp in enumerate(expected):
p = params[i]
assert set(p._fields) == set(exp._fields)
for key in exp._fields:
if key in ("value", "error"):
assert_allclose(getattr(p, key), getattr(exp, key), rtol=1e-2)
else:
assert getattr(p, key) == getattr(exp, key)
def test_from_array_func_2():
m = Minuit.from_array_func(func8, (2, 1),
grad=func8_grad,
error=(0.5, 0.5),
limit=((0, 2), (0, 2)),
fix=(False, True),
name=("a", "b"),
errordef=1,
print_level=0)
assert m.fitarg == {
"a": 2,
"b": 1,
"error_a": 0.5,
"error_b": 0.5,
"fix_a": False,
"fix_b": True,
"limit_a": (0, 2),
"limit_b": (0, 2)
}
m.migrad()
v = m.np_values()
assert_allclose(v, (1, 1), rtol=1e-2)
c = m.np_covariance()
assert_allclose(c, ((1, 0), (0, 0)), rtol=1e-2)
def functesthelper(f):
m = Minuit(f, print_level=0, pedantic=False)
m.migrad()
val = m.values
assert_allclose(val['x'], 2.)
assert_allclose(val['y'], 5.)
assert_allclose(m.fval, 10.)
assert m.matrix_accurate()
assert m.migrad_ok()
return m
def functesthelper(f):
m = Minuit(f, print_level=0, pedantic=False)
m.migrad()
val = m.values
assert_allclose(val['x'], 2.)
assert_allclose(val['y'], 5.)
assert_allclose(m.fval, 10.)
assert m.matrix_accurate()
assert m.migrad_ok()
return m
def functesthelper_paramlist(f, *params):
m = Minuit.from_parameter_list(f, *params, print_level=0, pedantic=False)
m.migrad()
val = m.values
assert_allclose(val['p0'], 2.)
assert_allclose(val['p1'], 5.)
assert_allclose(m.fval, 10.)
assert m.matrix_accurate()
assert m.migrad_ok()
return m
def test_mncontour_with_gradient():
m = Minuit(func3,
grad_fcn=func3_grad,
pedantic=False,
x=1.,
y=2.,
error_x=3.,
print_level=0)
m.migrad()
xminos, yminos, ctr = m.mncontour('x', 'y', numpoints=30)
xminos_t = m.minos('x')['x']
yminos_t = m.minos('y')['y']
assert_allclose(xminos.upper, xminos_t.upper)
assert_allclose(xminos.lower, xminos_t.lower)
assert_allclose(yminos.upper, yminos_t.upper)
assert_allclose(yminos.lower, yminos_t.lower)
assert len(ctr) == 30
assert len(ctr[0]) == 2
def test_fitarg():
m = Minuit(func4, print_level=-1, y=10., fix_y=True, limit_x=(0, 20.),
pedantic=False)
fitarg = m.fitarg
assert_allclose(fitarg['y'], 10.)
assert fitarg['fix_y'] is True
assert fitarg['limit_x'] == (0, 20)
m.migrad()
fitarg = m.fitarg
assert_allclose(fitarg['y'], 10.)
assert_allclose(fitarg['x'], 2., atol=1e-2)
assert_allclose(fitarg['z'], 7., atol=1e-2)
assert 'error_y' in fitarg
assert 'error_x' in fitarg
assert 'error_z' in fitarg
assert fitarg['fix_y'] is True
assert fitarg['limit_x'] == (0, 20)
def test_fitarg():
m = Minuit(
func4, print_level=-1, y=10.0, fix_y=True, limit_x=(0, 20.0), pedantic=False
)
fitarg = m.fitarg
assert_allclose(fitarg["y"], 10.0)
assert fitarg["fix_y"] is True
assert fitarg["limit_x"] == (0, 20)
m.migrad()
fitarg = m.fitarg
assert_allclose(fitarg["y"], 10.0)
assert_allclose(fitarg["x"], 2.0, atol=1e-2)
assert_allclose(fitarg["z"], 7.0, atol=1e-2)
assert "error_y" in fitarg
assert "error_x" in fitarg
assert "error_z" in fitarg
assert fitarg["fix_y"] is True
assert fitarg["limit_x"] == (0, 20)
def test_simple():
result = minimize(func, (1, 1, 1))
assert_allclose(result.x, (0, 1, 2), atol=1e-8)
assert_allclose(result.fun, 1)
assert result.nfev > 0
assert result.njev == 0
def test_oneside_outside():
m = Minuit(func3, limit_x=(None, 1), pedantic=False, print_level=0)
m.migrad()
assert_allclose(m.values['x'], 1)
def test_fix_param_with_gradient():
m = Minuit(func4, grad_fcn=func4_grad, print_level=0, pedantic=False)
m.migrad()
m.minos()
val = m.values
assert_allclose(val['x'], 2)
assert_allclose(val['y'], 5)
assert_allclose(val['z'], 7)
err = m.errors # second derivative
assert_allclose(err['x'], 2.236067977354171)
assert_allclose(err['y'], 3.1622776602288)
assert_allclose(err['z'], 2)
m.print_all_minos()
# now fix z = 10
m = Minuit(func4,
grad_fcn=func4_grad,
print_level=-1,
y=10.,
fix_y=True,
pedantic=False)
m.migrad()
val = m.values
assert_allclose(val['x'], 2)
assert_allclose(val['y'], 10)
assert_allclose(val['z'], 7)
assert_allclose(m.fval, 10. + 2.5)
free_param = m.list_of_vary_param()
fix_param = m.list_of_fixed_param()
assert 'x' in free_param
assert 'x' not in fix_param
assert 'y' in fix_param
assert 'y' not in free_param
assert 'z' not in fix_param
def test_np_matrix(self):
import numpy as np
actual = self.m.np_matrix()
expected = [[5., 0.], [0., 1.]]
assert_allclose(actual, expected)
assert isinstance(actual, np.ndarray)
def test_matrix(self):
actual = self.m.np_matrix()
expected = [[5., 0.], [0., 1.]]
assert_allclose(actual, expected)
def test_matrix_correlation(self):
actual = self.m.matrix(correlation=True)
expected = [[1., 0.], [0., 1.]]
assert_allclose(actual, expected)
def test_gradient():
result = minimize(func, (1, 1, 1), jac=grad)
assert_allclose(result.x, (0, 1, 2), atol=1e-8)
assert_allclose(result.fun, 1)
assert result.nfev > 0
assert result.njev > 0
def test_matrix(self):
actual = self.m.np_matrix()
expected = [[5., 0.], [0., 1.]]
assert_allclose(actual, expected)
def test_matrix_correlation(self):
actual = self.m.matrix(correlation=True)
expected = [[1., 0.], [0., 1.]]
assert_allclose(actual, expected)
def test_np_errors(self):
actual = self.m.np_errors()
expected = [2., 1.]
assert_allclose(actual, expected, atol=1e-8)
assert isinstance(actual, np.ndarray)
assert actual.shape == (2, )
def test_np_covariance(self):
actual = self.m.np_covariance()
expected = [[4., 0.], [0., 1.]]
assert_allclose(actual, expected, atol=1e-8)
assert isinstance(actual, np.ndarray)
assert actual.shape == (2, 2)
def test_np_matrix_correlation(self):
actual = self.m.np_matrix(correlation=True)
expected = [[1., 0.], [0., 1.]]
assert_allclose(actual, expected, atol=1e-8)
assert isinstance(actual, np.ndarray)
assert actual.shape == (2, 2)
def test_matrix(self):
actual = self.m.matrix()
expected = [[4., 0.], [0., 1.]]
assert_allclose(actual, expected, atol=1e-8)
def test_args(self):
actual = self.m.args
expected = [2., 5.]
assert_allclose(actual, expected, atol=1e-8)
def test_fix_param_with_gradient():
m = Minuit(func4, grad_fcn=func4_grad, print_level=0, pedantic=False)
m.migrad()
m.minos()
val = m.values
assert_allclose(val['x'], 2)
assert_allclose(val['y'], 5)
assert_allclose(val['z'], 7)
err = m.errors # second derivative
assert_allclose(err['x'], 2.236067977354171)
assert_allclose(err['y'], 3.1622776602288)
assert_allclose(err['z'], 2)
m.print_all_minos()
# now fix z = 10
m = Minuit(func4, grad_fcn=func4_grad, print_level=-1, y=10., fix_y=True, pedantic=False)
m.migrad()
val = m.values
assert_allclose(val['x'], 2)
assert_allclose(val['y'], 10)
assert_allclose(val['z'], 7)
assert_allclose(m.fval, 10. + 2.5)
free_param = m.list_of_vary_param()
fix_param = m.list_of_fixed_param()
assert 'x' in free_param
assert 'x' not in fix_param
assert 'y' in fix_param
assert 'y' not in free_param
assert 'z' not in fix_param
def test_oneside_outside():
m = Minuit(func3, limit_x=(None, 1), pedantic=False, print_level=0)
m.migrad()
assert_allclose(m.values['x'], 1)
def test_modify_param_state():
m = Minuit(func3, x=1, y=2, fix_y=True, pedantic=False, print_level=0)
m.migrad()
assert_allclose(m.np_values(), [2, 2], atol=1e-2)
assert_allclose(m.np_errors(), [2, 1], atol=1e-2)
m.fixed['y'] = False
m.values['x'] = 1
m.errors['x'] = 1
assert_allclose(m.np_values(), [1, 2], atol=1e-2)
assert_allclose(m.np_errors(), [1, 1], atol=1e-2)
m.migrad()
assert_allclose(m.np_values(), [2, 5], atol=1e-2)
assert_allclose(m.np_errors(), [2, 1], atol=1e-2)
m.values['y'] = 6
m.hesse() # does not change minimum
assert_allclose(m.np_values(), [2, 6], atol=1e-2)
assert_allclose(m.np_errors(), [2, 1], atol=1e-2)
def test_np_matrix_correlation(self):
import numpy as np
actual = self.m.np_matrix(correlation=True)
expected = [[1., 0.], [0., 1.]]
assert_allclose(actual, expected)
assert isinstance(actual, np.ndarray)
def test_np_matrix(self):
import numpy as np
actual = self.m.np_matrix()
expected = [[5., 0.], [0., 1.]]
assert_allclose(actual, expected)
assert isinstance(actual, np.ndarray)
def test_simple():
result = minimize(func, (1, 1, 1))
assert_allclose(result.x, (0, 1, 2), atol=1e-8)
assert_allclose(result.fun, 1)
assert result.nfev > 0
assert result.njev == 0
def test_np_matrix_correlation(self):
import numpy as np
actual = self.m.np_matrix(correlation=True)
expected = [[1., 0.], [0., 1.]]
assert_allclose(actual, expected)
assert isinstance(actual, np.ndarray)
def test_gradient():
result = minimize(func, (1, 1, 1), jac=grad)
assert_allclose(result.x, (0, 1, 2), atol=1e-8)
assert_allclose(result.fun, 1)
assert result.nfev > 0
assert result.njev > 0
def test_args():
result = minimize(func, np.ones(3), args=(5, ))
assert_allclose(result.x, (0, 1, 2), atol=1e-8)
assert_allclose(result.fun, 5)
assert result.nfev > 0
assert result.njev == 0
def test_args():
result = minimize(func, np.ones(3), args=(5,))
assert_allclose(result.x, (0, 1, 2), atol=1e-8)
assert_allclose(result.fun, 5)
assert result.nfev > 0
assert result.njev == 0
