def test_bug_11886():
def opt(x):
return x[0]**2 + x[1]**2
with np.testing.suppress_warnings() as sup:
sup.filter(PendingDeprecationWarning)
A = np.matrix(np.diag([1, 1]))
lin_cons = LinearConstraint(A, -1, np.inf)
minimize(opt, 2 * [1],
constraints=lin_cons) # just checking that there are no errors
def check_limits(self, method, default_iters):
for start_v in [[0.1, 0.1], [1, 1], [2, 2]]:
for mfev in [50, 500, 5000]:
self.funcalls = 0
res = optimize.minimize(self.slow_func,
start_v,
method=method,
options={"maxfev": mfev})
assert_(self.funcalls == res["nfev"])
if res["success"]:
assert_(res["nfev"] < mfev)
else:
assert_(res["nfev"] >= mfev)
for mit in [50, 500, 5000]:
res = optimize.minimize(self.slow_func,
start_v,
method=method,
options={"maxiter": mit})
if res["success"]:
assert_(res["nit"] <= mit)
else:
assert_(res["nit"] >= mit)
for mfev, mit in [[50, 50], [5000, 5000], [5000, np.inf]]:
self.funcalls = 0
res = optimize.minimize(self.slow_func,
start_v,
method=method,
options={
"maxiter": mit,
"maxfev": mfev
})
assert_(self.funcalls == res["nfev"])
if res["success"]:
assert_(res["nfev"] < mfev and res["nit"] <= mit)
else:
assert_(res["nfev"] >= mfev or res["nit"] >= mit)
for mfev, mit in [[np.inf, None], [None, np.inf]]:
self.funcalls = 0
res = optimize.minimize(self.slow_func,
start_v,
method=method,
options={
"maxiter": mit,
"maxfev": mfev
})
assert_(self.funcalls == res["nfev"])
if res["success"]:
if mfev is None:
assert_(res["nfev"] < default_iters * 2)
else:
assert_(res["nit"] <= default_iters * 2)
else:
assert_(res["nfev"] >= default_iters * 2
or res["nit"] >= default_iters * 2)
def test_attributes_present(self):
attributes = [
'nit', 'nfev', 'x', 'success', 'status', 'fun', 'message'
]
skip = {'cobyla': ['nit']}
for method in MINIMIZE_METHODS:
with suppress_warnings() as sup:
sup.filter(RuntimeWarning,
("Method .+ does not use (gradient|Hessian.*)"
" information"))
res = optimize.minimize(self.func,
self.x0,
method=method,
jac=self.jac,
hess=self.hess,
hessp=self.hessp)
for attribute in attributes:
if method in skip and attribute in skip[method]:
continue
assert hasattr(res, attribute)
assert_(attribute in dir(res))
# gh13001, OptimizeResult.message should be a str
assert isinstance(res.message, str)
def test_gh10880():
# checks that verbose reporting works with trust-constr
bnds = Bounds(1, 2)
opts = {'maxiter': 1000, 'verbose': 2}
minimize(lambda x: x**2,
x0=2.,
method='trust-constr',
bounds=bnds,
options=opts)
opts = {'maxiter': 1000, 'verbose': 3}
minimize(lambda x: x**2,
x0=2.,
method='trust-constr',
bounds=bnds,
options=opts)
def test_default_jac_and_hess(self):
def fun(x):
return (x - 1)**2
bounds = [(-2, 2)]
res = minimize(fun, x0=[-1.5], bounds=bounds, method='trust-constr')
assert_array_almost_equal(res.x, 1, decimal=5)
def test_multiple_constraint_objects(self):
fun = lambda x: (x[0] - 1)**2 + (x[1] - 2.5)**2 + (x[2] - 0.75)**2
x0 = [2, 0, 1]
coni = [] # only inequality constraints (can use cobyla)
methods = [
"trust-constr",
]
# mixed old and new
coni.append([{
'type': 'ineq',
'fun': lambda x: x[0] - 2 * x[1] + 2
},
NonlinearConstraint(lambda x: x[0] - x[1], -1, 1)])
coni.append([
LinearConstraint([1, -2, 0], -2, np.inf),
NonlinearConstraint(lambda x: x[0] - x[1], -1, 1)
])
coni.append([
NonlinearConstraint(lambda x: x[0] - 2 * x[1] + 2, 0, np.inf),
NonlinearConstraint(lambda x: x[0] - x[1], -1, 1)
])
for con in coni:
funs = {}
for method in methods:
with suppress_warnings() as sup:
sup.filter(UserWarning)
result = minimize(fun, x0, method=method, constraints=con)
funs[method] = result.fun
assert_allclose(funs['trust-constr'], .8, rtol=1e-4)
def test_args(self):
prob = MaratosTestArgs("a", 234)
result = minimize(prob.fun,
prob.x0, ("a", 234),
method='trust-constr',
jac=prob.grad,
hess=prob.hess,
bounds=prob.bounds,
constraints=prob.constr)
if prob.x_opt is not None:
assert_array_almost_equal(result.x, prob.x_opt, decimal=2)
# gtol
if result.status == 1:
assert_array_less(result.optimality, 1e-8)
# xtol
if result.status == 2:
assert_array_less(result.tr_radius, 1e-8)
if result.method == "tr_interior_point":
assert_array_less(result.barrier_parameter, 1e-8)
# max iter
if result.status in (0, 3):
raise RuntimeError("Invalid termination condition.")
def test_no_constraints():
res = minimize(rosenbrock_function,
np.array([0.1, -0.5, -5.0]),
options={"disp": False})
assert res.niter < 61 # SciPy version 1.5.0 needs 56 iterations
assert_allclose(res.x, [1, 1, 1], rtol=1e-4)
def test_respect_maxiter(self, method):
# Check that the number of iterations equals max_iter, assuming
# convergence doesn't establish before
MAXITER = 4
x0 = np.zeros(10)
sf = ScalarFunction(optimize.rosen, x0, (), optimize.rosen_der,
optimize.rosen_hess, None, None)
# Set options
kwargs = {'method': method, 'options': dict(maxiter=MAXITER)}
if method in ('Newton-CG', ):
kwargs['jac'] = sf.grad
elif method in ('trust-krylov', 'trust-exact', 'trust-ncg', 'dogleg',
'trust-constr'):
kwargs['jac'] = sf.grad
kwargs['hess'] = sf.hess
sol = optimize.minimize(sf.fun, x0, **kwargs)
assert sol.nit == MAXITER
assert sol.nfev >= sf.nfev
if hasattr(sol, 'njev'):
assert sol.njev >= sf.ngev
# method specific tests
if method == 'SLSQP':
assert sol.status == 9 # Iteration limit reached
def test_list_of_problems(self):
list_of_problems = [
Maratos(),
Maratos(constr_hess='2-point'),
Maratos(constr_hess=SR1()),
Maratos(constr_jac='2-point', constr_hess=SR1()),
MaratosGradInFunc(),
HyperbolicIneq(),
HyperbolicIneq(constr_hess='3-point'),
HyperbolicIneq(constr_hess=BFGS()),
HyperbolicIneq(constr_jac='3-point', constr_hess=BFGS()),
Rosenbrock(),
IneqRosenbrock(),
EqIneqRosenbrock(),
BoundedRosenbrock(),
Elec(n_electrons=2),
Elec(n_electrons=2, constr_hess='2-point'),
Elec(n_electrons=2, constr_hess=SR1()),
Elec(n_electrons=2, constr_jac='3-point', constr_hess=SR1())
]
for prob in list_of_problems:
for grad in (prob.grad, '3-point', False):
for hess in (prob.hess, '3-point', SR1(),
BFGS(exception_strategy='damp_update'),
BFGS(exception_strategy='skip_update')):
# Remove exceptions
if grad in ('2-point', '3-point', 'cs', False) and \
hess in ('2-point', '3-point', 'cs'):
continue
if prob.grad is True and grad in ('3-point', False):
continue
with suppress_warnings() as sup:
sup.filter(UserWarning, "delta_grad == 0.0")
result = minimize(prob.fun,
prob.x0,
method='trust-constr',
jac=grad,
hess=hess,
bounds=prob.bounds,
constraints=prob.constr)
if prob.x_opt is not None:
assert_array_almost_equal(result.x,
prob.x_opt,
decimal=5)
# gtol
if result.status == 1:
assert_array_less(result.optimality, 1e-8)
# xtol
if result.status == 2:
assert_array_less(result.tr_radius, 1e-8)
if result.method == "tr_interior_point":
assert_array_less(result.barrier_parameter, 1e-8)
# max iter
if result.status in (0, 3):
raise RuntimeError("Invalid termination condition.")
def test_minimize_automethod(self):
def f(x):
return x**2
def cons(x):
return x - 2
x0 = np.array([10.])
with suppress_warnings() as sup:
sup.filter(UserWarning, "delta_grad == 0.*")
sol_0 = optimize.minimize(f, x0)
sol_1 = optimize.minimize(f,
x0,
constraints=[{
'type': 'ineq',
'fun': cons
}])
sol_2 = optimize.minimize(f, x0, bounds=[(5, 10)])
sol_3 = optimize.minimize(f,
x0,
constraints=[{
'type': 'ineq',
'fun': cons
}],
bounds=[(5, 10)])
sol_4 = optimize.minimize(f,
x0,
constraints=[{
'type': 'ineq',
'fun': cons
}],
bounds=[(1, 10)])
for sol in [sol_0, sol_1, sol_2, sol_3, sol_4]:
assert_(sol.success)
assert_allclose(sol_0.x, 0, atol=1e-7)
# These last four were opened up from atol=1e-7 for scipy 1.6.0
# likely do to a different algorithm being used instead of trust-constr
# only methods SLSQP, L-BFGS-B, and BFGS are used by minimize
# automatically. Here, we're forced to used trust-constr for
# everything since that's all that is available.
assert_allclose(sol_1.x, 2, atol=1e-4, rtol=1e-4)
assert_allclose(sol_2.x, 5, atol=1e-4, rtol=1e-4)
assert_allclose(sol_3.x, 5, atol=1e-4, rtol=1e-4)
assert_allclose(sol_4.x, 2, atol=1e-4, rtol=1e-4)
def test_gh10771(self):
# check that minimize passes bounds and constraints to a custom
# minimizer without altering them.
bounds = [(-2, 2), (0, 3)]
constraints = 'constraints'
def custmin(fun, x0, **options):
assert options['bounds'] is bounds
assert options['constraints'] is constraints
return optimize.OptimizeResult()
x0 = [1, 1]
optimize.minimize(optimize.rosen,
x0,
method=custmin,
bounds=bounds,
constraints=constraints)
def test_no_constraints(self):
prob = Rosenbrock()
result = minimize(prob.fun,
prob.x0,
method='trust-constr',
jac=prob.grad,
hess=prob.hess)
assert_array_almost_equal(result.x, prob.x_opt, decimal=5)
def test_bounds_class():
res = minimize(
rosenbrock_function,
np.array([0.1, -0.5, -5.0]),
bounds=Bounds([-10, -10, -np.inf], [10, np.inf, np.inf]),
method="trust-constr",
options={"disp": False},
)
assert res.niter < 110 # SciPy version 1.5.0 needs 105 iterations
assert_allclose(res.x, [1, 1, 1], rtol=1e-4)
def test_duplicate_evaluations(self, method):
# check that there are no duplicate evaluations for any methods
jac = hess = None
if method in ('newton-cg', 'trust-krylov', 'trust-exact', 'trust-ncg',
'dogleg'):
jac = self.grad
if method in ('trust-krylov', 'trust-exact', 'trust-ncg', 'dogleg'):
hess = self.hess
with np.errstate(invalid='ignore'), suppress_warnings() as sup:
# for trust-constr
sup.filter(UserWarning, "delta_grad == 0.*")
optimize.minimize(self.func,
self.startparams,
method=method,
jac=jac,
hess=hess)
for i in range(1, len(self.trace)):
if np.array_equal(self.trace[i - 1], self.trace[i]):
raise RuntimeError(
"Duplicate evaluations made by {}".format(method))
def test_custom(self):
# This function comes from the documentation example.
def custmin(fun,
x0,
args=(),
maxfev=None,
stepsize=0.1,
maxiter=100,
callback=None,
**options):
bestx = x0
besty = fun(x0)
funcalls = 1
niter = 0
improved = True
stop = False
while improved and not stop and niter < maxiter:
improved = False
niter += 1
for dim in range(np.size(x0)):
for s in [bestx[dim] - stepsize, bestx[dim] + stepsize]:
testx = np.copy(bestx)
testx[dim] = s
testy = fun(testx, *args)
funcalls += 1
if testy < besty:
besty = testy
bestx = testx
improved = True
if callback is not None:
callback(bestx)
if maxfev is not None and funcalls >= maxfev:
stop = True
break
return optimize.OptimizeResult(fun=besty,
x=bestx,
nit=niter,
nfev=funcalls,
success=(niter > 1))
x0 = [1.35, 0.9, 0.8, 1.1, 1.2]
res = optimize.minimize(optimize.rosen,
x0,
method=custmin,
options=dict(stepsize=0.05))
assert_allclose(res.x, 1.0, rtol=1e-4, atol=1e-4)
def test_nan_values(self, method):
# Check nan values result to failed exit status
np.random.seed(1234)
count = [0]
def func(x):
return np.nan
def func2(x):
count[0] += 1
if count[0] > 2:
return np.nan
else:
return np.random.rand()
def grad(x):
return np.array([1.0])
def hess(x):
return np.array([[1.0]])
x0 = np.array([1.0])
needs_grad = method in ('newton-cg', 'trust-krylov', 'trust-exact',
'trust-ncg', 'dogleg')
needs_hess = method in ('trust-krylov', 'trust-exact', 'trust-ncg',
'dogleg')
funcs = [func, func2]
grads = [grad] if needs_grad else [grad, None]
hesss = [hess] if needs_hess else [hess, None]
with np.errstate(invalid='ignore'), suppress_warnings() as sup:
sup.filter(UserWarning, "delta_grad == 0.*")
sup.filter(RuntimeWarning, ".*does not use Hessian.*")
sup.filter(RuntimeWarning, ".*does not use gradient.*")
for f, g, h in itertools.product(funcs, grads, hesss):
count = [0]
sol = optimize.minimize(f,
x0,
jac=g,
hess=h,
method=method,
options=dict(maxiter=20))
assert_equal(sol.success, False)
def test_constraint_dictionary_2(self):
fun = lambda x: (x[0] - 1)**2 + (x[1] - 2.5)**2
cons = {
'type': 'eq',
'fun': lambda x, p1, p2: p1 * x[0] - p2 * x[1],
'args': (1, 1.1),
'jac': lambda x, p1, p2: np.array([[p1, -p2]])
}
with suppress_warnings() as sup:
sup.filter(UserWarning, "delta_grad == 0.0")
res = minimize(fun,
self.x0,
method=self.method,
bounds=self.bnds,
constraints=cons)
assert_allclose(res.x, [1.7918552, 1.62895927])
assert_allclose(res.fun, 1.3857466063348418)
def test_constraint_dictionary_3(self):
fun = lambda x: (x[0] - 1)**2 + (x[1] - 2.5)**2
cons = [{
'type': 'ineq',
'fun': lambda x: x[0] - 2 * x[1] + 2
},
NonlinearConstraint(lambda x: x[0] - x[1], 0, 0)]
with suppress_warnings() as sup:
sup.filter(UserWarning, "delta_grad == 0.0")
res = minimize(fun,
self.x0,
method=self.method,
bounds=self.bnds,
constraints=cons)
assert_allclose(res.x, [1.75, 1.75], rtol=1e-4)
assert_allclose(res.fun, 1.125, rtol=1e-4)
def test_issue_9044(self):
# https://github.com/scipy/scipy/issues/9044
# Test the returned `OptimizeResult` contains keys consistent with
# other solvers.
def callback(x, info):
assert_('nit' in info)
assert_('niter' in info)
result = minimize(lambda x: x**2, [0],
jac=lambda x: 2 * x,
hess=lambda x: 2,
callback=callback,
method='trust-constr')
assert_(result.get('success'))
assert_(result.get('nit', -1) == 1)
# Also check existence of the 'niter' attribute, for backward
# compatibility
assert_(result.get('niter', -1) == 1)
def test_respect_maxiter_trust_constr_ineq_constraints(self):
# special case of minimization with trust-constr and inequality
# constraints to check maxiter limit is obeyed when using internal
# method 'tr_interior_point'
MAXITER = 4
f = optimize.rosen
jac = optimize.rosen_der
hess = optimize.rosen_hess
fun = lambda x: np.array([0.2 * x[0] - 0.4 * x[1] - 0.33 * x[2]])
cons = ({'type': 'ineq', 'fun': fun}, )
x0 = np.zeros(10)
sol = optimize.minimize(f,
x0,
constraints=cons,
jac=jac,
hess=hess,
method='trust-constr',
options=dict(maxiter=MAXITER))
assert sol.nit == MAXITER
def test_constraint_dictionary_1(self):
fun = lambda x: (x[0] - 1)**2 + (x[1] - 2.5)**2
cons = ({
'type': 'ineq',
'fun': lambda x: x[0] - 2 * x[1] + 2
}, {
'type': 'ineq',
'fun': lambda x: -x[0] - 2 * x[1] + 6
}, {
'type': 'ineq',
'fun': lambda x: -x[0] + 2 * x[1] + 2
})
with suppress_warnings() as sup:
sup.filter(UserWarning, "delta_grad == 0.0")
res = minimize(fun,
self.x0,
method=self.method,
bounds=self.bnds,
constraints=cons)
assert_allclose(res.x, [1.4, 1.7], rtol=1e-4)
assert_allclose(res.fun, 0.8, rtol=1e-4)
def test_empty_constraint(self):
def function(x):
return x[0]**2 + x[1]**2
def functionjacobian(x):
return np.array([2. * x[0], 2. * x[1]])
def functionhvp(x, v):
return 2. * v
def constraint(x):
return np.array([x[0]**2 - x[1]**2])
def constraintjacobian(x):
return np.array([[2 * x[0], -2 * x[1]]])
def constraintlcoh(x, v):
return np.array([[2., 0.], [0., -2.]]) * v[0]
constraint = NonlinearConstraint(constraint, 1., np.inf,
constraintjacobian, constraintlcoh)
startpoint = [1., 2.]
bounds = Bounds([-np.inf, -np.inf], [np.inf, np.inf])
result = minimize(function,
startpoint,
method='trust-constr',
jac=functionjacobian,
hessp=functionhvp,
constraints=[constraint],
bounds=bounds)
# Note that the SciPy 1.6.0 version of trust-constr can achieve decimal=4
# Likely due to differences in factorization method
# This version does not support the NormalEquation or QRFactorization methods
assert_array_almost_equal(abs(result.x), np.array([1, 0]), decimal=2)
def test_generate_pareto_data(data, factorization_method, rtol, iter_buffer):
inputs = np.array(data["inputs"])
outputs = np.array(data["outputs"])
y_axis_index = data["y_axis_index"]
y_axis_goal = data["y_axis_goal"]
x_axis_index = data["x_axis_index"]
x_axis_goal = data["x_axis_goal"]
bounds = data["bounds"]
output_targets = data["output_targets"]
baseline_pareto_points = np.array(data["pareto_points"])
baseline_total_iterations = data["total_iterations"]
terms, response_surfaces = get_response_surface(inputs, outputs)
# check analytical gradients against numerical gradients
for i in range(len(response_surfaces)):
test_points = uniform(
low=[pair[0] for pair in bounds],
high=[pair[1] for pair in bounds],
size=(10, len(bounds)),
)
for test_point in test_points:
difference = check_grad(
partial(evaluate_response_surface, terms,
response_surfaces[i]),
partial(evaluate_response_surface_grad, terms,
response_surfaces[i]),
test_point,
)
assert (difference / evaluate_response_surface(
terms, response_surfaces[i], test_point) < 1e-4)
# add equality constraints for any outputs with targets
constraints = []
for index, target in enumerate(output_targets):
if target:
constraints.append(
NonlinearConstraint(
partial(evaluate_response_surface, terms,
response_surfaces[index]),
target,
target,
jac=partial(evaluate_response_surface_grad, terms,
response_surfaces[index]),
))
def objective_func(x, index, sign=1.0):
return evaluate_response_surface(terms,
response_surfaces[index],
x,
factor=sign)
def objective_func_grad(x, index, sign=1.0):
return evaluate_response_surface_grad(terms,
response_surfaces[index],
x,
factor=sign)
x0 = np.array([(pair[0] + pair[1]) / 2 for pair in bounds])
# get the x-axis range for the pareto optimization
with suppress_warnings() as sup:
sup.filter(UserWarning, "delta_grad == 0.*")
# purposely leaving out jac here, will test below
res = minimize(
objective_func,
x0,
args=(x_axis_index, -1.0),
bounds=bounds,
constraints=constraints,
options={
"disp": False,
"factorization_method": factorization_method
},
)
x_max = -res.fun
# x_min_starting_point = X[y[:,x_axis_index].argmin(),:]
res = minimize(
objective_func,
x0,
args=(x_axis_index, 1.0),
bounds=bounds,
constraints=constraints,
method="trust-constr",
options={
"disp": False,
"factorization_method": factorization_method
},
)
x_min = res.fun
pareto_points = np.linspace(x_min,
x_max,
num=baseline_pareto_points.shape[0])
# find the actual pareto points
pareto_input_values = []
y_axis_sign = 1 if y_axis_goal == "min" else -1
total_iterations = 0
for x_value in pareto_points:
if x_axis_goal == "min":
limits = (-np.inf, x_value)
else:
limits = (x_value, np.inf)
current_constraint = NonlinearConstraint(
partial(evaluate_response_surface, terms,
response_surfaces[x_axis_index]),
*limits,
jac=partial(evaluate_response_surface_grad, terms,
response_surfaces[x_axis_index]))
res = minimize(
objective_func,
x0,
args=(y_axis_index, y_axis_sign),
bounds=bounds,
constraints=constraints + [
current_constraint,
],
jac=objective_func_grad,
method="trust-constr",
options={
"disp": False,
"factorization_method": factorization_method
},
)
total_iterations += res.nit
pareto_input_values.append(res.x)
pareto_output_values = []
for current_input in pareto_input_values:
current_output = []
for i in range(outputs.shape[1]):
current_output.append(
evaluate_response_surface(terms, response_surfaces[i],
current_input))
pareto_output_values.append(current_output)
pareto_output_values = np.array(pareto_output_values)
assert total_iterations < baseline_total_iterations + iter_buffer
assert_allclose(pareto_output_values, baseline_pareto_points, rtol=rtol)
def routine(*a, **kw):
kw['method'] = method
return optimize.minimize(*a, **kw)
def test_individual_constraint_objects(self):
fun = lambda x: (x[0] - 1)**2 + (x[1] - 2.5)**2 + (x[2] - 0.75)**2
x0 = [2, 0, 1]
cone = [] # with equality constraints (can't use cobyla)
coni = [] # only inequality constraints (can use cobyla)
methods = [
"trust-constr",
]
# nonstandard data types for constraint equality bounds
cone.append(NonlinearConstraint(lambda x: x[0] - x[1], 1, 1))
cone.append(NonlinearConstraint(lambda x: x[0] - x[1], [1.21], [1.21]))
cone.append(
NonlinearConstraint(lambda x: x[0] - x[1], 1.21, np.array([1.21])))
# multiple equalities
cone.append(
NonlinearConstraint(lambda x: [x[0] - x[1], x[1] - x[2]], 1.21,
1.21)) # two same equalities
cone.append(
NonlinearConstraint(lambda x: [x[0] - x[1], x[1] - x[2]],
[1.21, 1.4],
[1.21, 1.4])) # two different equalities
cone.append(
NonlinearConstraint(lambda x: [x[0] - x[1], x[1] - x[2]],
[1.21, 1.21],
1.21)) # equality specified two ways
cone.append(
NonlinearConstraint(lambda x: [x[0] - x[1], x[1] - x[2]],
[1.21, -np.inf],
[1.21, np.inf])) # equality + unbounded
# nonstandard data types for constraint inequality bounds
coni.append(NonlinearConstraint(lambda x: x[0] - x[1], 1.21, np.inf))
coni.append(NonlinearConstraint(lambda x: x[0] - x[1], [1.21], np.inf))
coni.append(
NonlinearConstraint(lambda x: x[0] - x[1], 1.21,
np.array([np.inf])))
coni.append(NonlinearConstraint(lambda x: x[0] - x[1], -np.inf, -3))
coni.append(
NonlinearConstraint(lambda x: x[0] - x[1], np.array(-np.inf), -3))
# multiple inequalities/equalities
coni.append(
NonlinearConstraint(lambda x: [x[0] - x[1], x[1] - x[2]], 1.21,
np.inf)) # two same inequalities
cone.append(
NonlinearConstraint(lambda x: [x[0] - x[1], x[1] - x[2]],
[1.21, -np.inf],
[1.21, 1.4])) # mixed equality/inequality
coni.append(
NonlinearConstraint(lambda x: [x[0] - x[1], x[1] - x[2]],
[1.1, .8],
[1.2, 1.4])) # bounded above and below
coni.append(
NonlinearConstraint(lambda x: [x[0] - x[1], x[1] - x[2]],
[-1.2, -1.4],
[-1.1, -.8])) # - bounded above and below
# quick check of LinearConstraint class (very little new code to test)
cone.append(LinearConstraint([1, -1, 0], 1.21, 1.21))
cone.append(LinearConstraint([[1, -1, 0], [0, 1, -1]], 1.21, 1.21))
cone.append(
LinearConstraint([[1, -1, 0], [0, 1, -1]], [1.21, -np.inf],
[1.21, 1.4]))
# Solutions for SciPy 1.6.0 trust-constr algorithm
solutions = [
3.672050010240001, 3.672050010240001, 3.672050010240001,
1.1250000102400013, 1.1250000102400013, 4.114869685317061,
3.4616666889075245, 3.7616666954827016
]
for i, con in enumerate(coni):
funs = {}
for method in methods:
with suppress_warnings() as sup:
sup.filter(UserWarning)
result = minimize(fun, x0, method=method, constraints=con)
funs[method] = result.fun
assert_allclose(funs['trust-constr'], solutions[i], rtol=1e-3)
# Solutions from SciPy 1.6.0 trust-constr algorithm
solutions = [
3.125000000000001, 3.67205, 3.67205, 4.114866666666668,
4.345399999999999, 4.114866666666668, 3.67205, 3.67205,
3.672050000000001, 4.114866666666666, 3.6720500000000005
]
for i, con in enumerate(cone):
funs = {}
for method in methods[::2]: # skip cobyla
with suppress_warnings() as sup:
sup.filter(UserWarning)
result = minimize(fun, x0, method=method, constraints=con)
funs[method] = result.fun
assert_allclose(funs['trust-constr'], solutions[i], rtol=1e-5)
