ai-content-maker/.venv/Lib/site-packages/scipy/optimize/tests/test_milp.py

386 lines
14 KiB
Python

"""
Unit test for Mixed Integer Linear Programming
"""
import re
import numpy as np
from numpy.testing import assert_allclose, assert_array_equal
import pytest
from .test_linprog import magic_square
from scipy.optimize import milp, Bounds, LinearConstraint
from scipy import sparse
def test_milp_iv():
message = "`c` must be a dense array"
with pytest.raises(ValueError, match=message):
milp(sparse.coo_array([0, 0]))
message = "`c` must be a one-dimensional array of finite numbers with"
with pytest.raises(ValueError, match=message):
milp(np.zeros((3, 4)))
with pytest.raises(ValueError, match=message):
milp([])
with pytest.raises(ValueError, match=message):
milp(None)
message = "`bounds` must be convertible into an instance of..."
with pytest.raises(ValueError, match=message):
milp(1, bounds=10)
message = "`constraints` (or each element within `constraints`) must be"
with pytest.raises(ValueError, match=re.escape(message)):
milp(1, constraints=10)
with pytest.raises(ValueError, match=re.escape(message)):
milp(np.zeros(3), constraints=([[1, 2, 3]], [2, 3], [2, 3]))
with pytest.raises(ValueError, match=re.escape(message)):
milp(np.zeros(2), constraints=([[1, 2]], [2], sparse.coo_array([2])))
message = "The shape of `A` must be (len(b_l), len(c))."
with pytest.raises(ValueError, match=re.escape(message)):
milp(np.zeros(3), constraints=([[1, 2]], [2], [2]))
message = "`integrality` must be a dense array"
with pytest.raises(ValueError, match=message):
milp([1, 2], integrality=sparse.coo_array([1, 2]))
message = ("`integrality` must contain integers 0-3 and be broadcastable "
"to `c.shape`.")
with pytest.raises(ValueError, match=message):
milp([1, 2, 3], integrality=[1, 2])
with pytest.raises(ValueError, match=message):
milp([1, 2, 3], integrality=[1, 5, 3])
message = "Lower and upper bounds must be dense arrays."
with pytest.raises(ValueError, match=message):
milp([1, 2, 3], bounds=([1, 2], sparse.coo_array([3, 4])))
message = "`lb`, `ub`, and `keep_feasible` must be broadcastable."
with pytest.raises(ValueError, match=message):
milp([1, 2, 3], bounds=([1, 2], [3, 4, 5]))
with pytest.raises(ValueError, match=message):
milp([1, 2, 3], bounds=([1, 2, 3], [4, 5]))
message = "`bounds.lb` and `bounds.ub` must contain reals and..."
with pytest.raises(ValueError, match=message):
milp([1, 2, 3], bounds=([1, 2], [3, 4]))
with pytest.raises(ValueError, match=message):
milp([1, 2, 3], bounds=([1, 2, 3], ["3+4", 4, 5]))
with pytest.raises(ValueError, match=message):
milp([1, 2, 3], bounds=([1, 2, 3], [set(), 4, 5]))
@pytest.mark.xfail(run=False,
reason="Needs to be fixed in `_highs_wrapper`")
def test_milp_options(capsys):
# run=False now because of gh-16347
message = "Unrecognized options detected: {'ekki'}..."
options = {'ekki': True}
with pytest.warns(RuntimeWarning, match=message):
milp(1, options=options)
A, b, c, numbers, M = magic_square(3)
options = {"disp": True, "presolve": False, "time_limit": 0.05}
res = milp(c=c, constraints=(A, b, b), bounds=(0, 1), integrality=1,
options=options)
captured = capsys.readouterr()
assert "Presolve is switched off" in captured.out
assert "Time Limit Reached" in captured.out
assert not res.success
def test_result():
A, b, c, numbers, M = magic_square(3)
res = milp(c=c, constraints=(A, b, b), bounds=(0, 1), integrality=1)
assert res.status == 0
assert res.success
msg = "Optimization terminated successfully. (HiGHS Status 7:"
assert res.message.startswith(msg)
assert isinstance(res.x, np.ndarray)
assert isinstance(res.fun, float)
assert isinstance(res.mip_node_count, int)
assert isinstance(res.mip_dual_bound, float)
assert isinstance(res.mip_gap, float)
A, b, c, numbers, M = magic_square(6)
res = milp(c=c*0, constraints=(A, b, b), bounds=(0, 1), integrality=1,
options={'time_limit': 0.05})
assert res.status == 1
assert not res.success
msg = "Time limit reached. (HiGHS Status 13:"
assert res.message.startswith(msg)
assert (res.fun is res.mip_dual_bound is res.mip_gap
is res.mip_node_count is res.x is None)
res = milp(1, bounds=(1, -1))
assert res.status == 2
assert not res.success
msg = "The problem is infeasible. (HiGHS Status 8:"
assert res.message.startswith(msg)
assert (res.fun is res.mip_dual_bound is res.mip_gap
is res.mip_node_count is res.x is None)
res = milp(-1)
assert res.status == 3
assert not res.success
msg = "The problem is unbounded. (HiGHS Status 10:"
assert res.message.startswith(msg)
assert (res.fun is res.mip_dual_bound is res.mip_gap
is res.mip_node_count is res.x is None)
def test_milp_optional_args():
# check that arguments other than `c` are indeed optional
res = milp(1)
assert res.fun == 0
assert_array_equal(res.x, [0])
def test_milp_1():
# solve magic square problem
n = 3
A, b, c, numbers, M = magic_square(n)
A = sparse.csc_array(A) # confirm that sparse arrays are accepted
res = milp(c=c*0, constraints=(A, b, b), bounds=(0, 1), integrality=1)
# check that solution is a magic square
x = np.round(res.x)
s = (numbers.flatten() * x).reshape(n**2, n, n)
square = np.sum(s, axis=0)
np.testing.assert_allclose(square.sum(axis=0), M)
np.testing.assert_allclose(square.sum(axis=1), M)
np.testing.assert_allclose(np.diag(square).sum(), M)
np.testing.assert_allclose(np.diag(square[:, ::-1]).sum(), M)
def test_milp_2():
# solve MIP with inequality constraints and all integer constraints
# source: slide 5,
# https://www.cs.upc.edu/~erodri/webpage/cps/theory/lp/milp/slides.pdf
# also check that `milp` accepts all valid ways of specifying constraints
c = -np.ones(2)
A = [[-2, 2], [-8, 10]]
b_l = [1, -np.inf]
b_u = [np.inf, 13]
linear_constraint = LinearConstraint(A, b_l, b_u)
# solve original problem
res1 = milp(c=c, constraints=(A, b_l, b_u), integrality=True)
res2 = milp(c=c, constraints=linear_constraint, integrality=True)
res3 = milp(c=c, constraints=[(A, b_l, b_u)], integrality=True)
res4 = milp(c=c, constraints=[linear_constraint], integrality=True)
res5 = milp(c=c, integrality=True,
constraints=[(A[:1], b_l[:1], b_u[:1]),
(A[1:], b_l[1:], b_u[1:])])
res6 = milp(c=c, integrality=True,
constraints=[LinearConstraint(A[:1], b_l[:1], b_u[:1]),
LinearConstraint(A[1:], b_l[1:], b_u[1:])])
res7 = milp(c=c, integrality=True,
constraints=[(A[:1], b_l[:1], b_u[:1]),
LinearConstraint(A[1:], b_l[1:], b_u[1:])])
xs = np.array([res1.x, res2.x, res3.x, res4.x, res5.x, res6.x, res7.x])
funs = np.array([res1.fun, res2.fun, res3.fun,
res4.fun, res5.fun, res6.fun, res7.fun])
np.testing.assert_allclose(xs, np.broadcast_to([1, 2], xs.shape))
np.testing.assert_allclose(funs, -3)
# solve relaxed problem
res = milp(c=c, constraints=(A, b_l, b_u))
np.testing.assert_allclose(res.x, [4, 4.5])
np.testing.assert_allclose(res.fun, -8.5)
def test_milp_3():
# solve MIP with inequality constraints and all integer constraints
# source: https://en.wikipedia.org/wiki/Integer_programming#Example
c = [0, -1]
A = [[-1, 1], [3, 2], [2, 3]]
b_u = [1, 12, 12]
b_l = np.full_like(b_u, -np.inf, dtype=np.float64)
constraints = LinearConstraint(A, b_l, b_u)
integrality = np.ones_like(c)
# solve original problem
res = milp(c=c, constraints=constraints, integrality=integrality)
assert_allclose(res.fun, -2)
# two optimal solutions possible, just need one of them
assert np.allclose(res.x, [1, 2]) or np.allclose(res.x, [2, 2])
# solve relaxed problem
res = milp(c=c, constraints=constraints)
assert_allclose(res.fun, -2.8)
assert_allclose(res.x, [1.8, 2.8])
def test_milp_4():
# solve MIP with inequality constraints and only one integer constraint
# source: https://www.mathworks.com/help/optim/ug/intlinprog.html
c = [8, 1]
integrality = [0, 1]
A = [[1, 2], [-4, -1], [2, 1]]
b_l = [-14, -np.inf, -np.inf]
b_u = [np.inf, -33, 20]
constraints = LinearConstraint(A, b_l, b_u)
bounds = Bounds(-np.inf, np.inf)
res = milp(c, integrality=integrality, bounds=bounds,
constraints=constraints)
assert_allclose(res.fun, 59)
assert_allclose(res.x, [6.5, 7])
def test_milp_5():
# solve MIP with inequality and equality constraints
# source: https://www.mathworks.com/help/optim/ug/intlinprog.html
c = [-3, -2, -1]
integrality = [0, 0, 1]
lb = [0, 0, 0]
ub = [np.inf, np.inf, 1]
bounds = Bounds(lb, ub)
A = [[1, 1, 1], [4, 2, 1]]
b_l = [-np.inf, 12]
b_u = [7, 12]
constraints = LinearConstraint(A, b_l, b_u)
res = milp(c, integrality=integrality, bounds=bounds,
constraints=constraints)
# there are multiple solutions
assert_allclose(res.fun, -12)
@pytest.mark.slow
@pytest.mark.timeout(120) # prerelease_deps_coverage_64bit_blas job
def test_milp_6():
# solve a larger MIP with only equality constraints
# source: https://www.mathworks.com/help/optim/ug/intlinprog.html
integrality = 1
A_eq = np.array([[22, 13, 26, 33, 21, 3, 14, 26],
[39, 16, 22, 28, 26, 30, 23, 24],
[18, 14, 29, 27, 30, 38, 26, 26],
[41, 26, 28, 36, 18, 38, 16, 26]])
b_eq = np.array([7872, 10466, 11322, 12058])
c = np.array([2, 10, 13, 17, 7, 5, 7, 3])
res = milp(c=c, constraints=(A_eq, b_eq, b_eq), integrality=integrality)
np.testing.assert_allclose(res.fun, 1854)
def test_infeasible_prob_16609():
# Ensure presolve does not mark trivially infeasible problems
# as Optimal -- see gh-16609
c = [1.0, 0.0]
integrality = [0, 1]
lb = [0, -np.inf]
ub = [np.inf, np.inf]
bounds = Bounds(lb, ub)
A_eq = [[0.0, 1.0]]
b_eq = [0.5]
constraints = LinearConstraint(A_eq, b_eq, b_eq)
res = milp(c, integrality=integrality, bounds=bounds,
constraints=constraints)
np.testing.assert_equal(res.status, 2)
_msg_time = "Time limit reached. (HiGHS Status 13:"
_msg_iter = "Iteration limit reached. (HiGHS Status 14:"
@pytest.mark.skipif(np.intp(0).itemsize < 8,
reason="Unhandled 32-bit GCC FP bug")
@pytest.mark.slow
@pytest.mark.parametrize(["options", "msg"], [({"time_limit": 0.1}, _msg_time),
({"node_limit": 1}, _msg_iter)])
def test_milp_timeout_16545(options, msg):
# Ensure solution is not thrown away if MILP solver times out
# -- see gh-16545
rng = np.random.default_rng(5123833489170494244)
A = rng.integers(0, 5, size=(100, 100))
b_lb = np.full(100, fill_value=-np.inf)
b_ub = np.full(100, fill_value=25)
constraints = LinearConstraint(A, b_lb, b_ub)
variable_lb = np.zeros(100)
variable_ub = np.ones(100)
variable_bounds = Bounds(variable_lb, variable_ub)
integrality = np.ones(100)
c_vector = -np.ones(100)
res = milp(
c_vector,
integrality=integrality,
bounds=variable_bounds,
constraints=constraints,
options=options,
)
assert res.message.startswith(msg)
assert res["x"] is not None
# ensure solution is feasible
x = res["x"]
tol = 1e-8 # sometimes needed due to finite numerical precision
assert np.all(b_lb - tol <= A @ x) and np.all(A @ x <= b_ub + tol)
assert np.all(variable_lb - tol <= x) and np.all(x <= variable_ub + tol)
assert np.allclose(x, np.round(x))
def test_three_constraints_16878():
# `milp` failed when exactly three constraints were passed
# Ensure that this is no longer the case.
rng = np.random.default_rng(5123833489170494244)
A = rng.integers(0, 5, size=(6, 6))
bl = np.full(6, fill_value=-np.inf)
bu = np.full(6, fill_value=10)
constraints = [LinearConstraint(A[:2], bl[:2], bu[:2]),
LinearConstraint(A[2:4], bl[2:4], bu[2:4]),
LinearConstraint(A[4:], bl[4:], bu[4:])]
constraints2 = [(A[:2], bl[:2], bu[:2]),
(A[2:4], bl[2:4], bu[2:4]),
(A[4:], bl[4:], bu[4:])]
lb = np.zeros(6)
ub = np.ones(6)
variable_bounds = Bounds(lb, ub)
c = -np.ones(6)
res1 = milp(c, bounds=variable_bounds, constraints=constraints)
res2 = milp(c, bounds=variable_bounds, constraints=constraints2)
ref = milp(c, bounds=variable_bounds, constraints=(A, bl, bu))
assert res1.success and res2.success
assert_allclose(res1.x, ref.x)
assert_allclose(res2.x, ref.x)
@pytest.mark.xslow
def test_mip_rel_gap_passdown():
# Solve problem with decreasing mip_gap to make sure mip_rel_gap decreases
# Adapted from test_linprog::TestLinprogHiGHSMIP::test_mip_rel_gap_passdown
# MIP taken from test_mip_6 above
A_eq = np.array([[22, 13, 26, 33, 21, 3, 14, 26],
[39, 16, 22, 28, 26, 30, 23, 24],
[18, 14, 29, 27, 30, 38, 26, 26],
[41, 26, 28, 36, 18, 38, 16, 26]])
b_eq = np.array([7872, 10466, 11322, 12058])
c = np.array([2, 10, 13, 17, 7, 5, 7, 3])
mip_rel_gaps = [0.25, 0.01, 0.001]
sol_mip_gaps = []
for mip_rel_gap in mip_rel_gaps:
res = milp(c=c, bounds=(0, np.inf), constraints=(A_eq, b_eq, b_eq),
integrality=True, options={"mip_rel_gap": mip_rel_gap})
# assert that the solution actually has mip_gap lower than the
# required mip_rel_gap supplied
assert res.mip_gap <= mip_rel_gap
# check that `res.mip_gap` is as defined in the documentation
assert res.mip_gap == (res.fun - res.mip_dual_bound)/res.fun
sol_mip_gaps.append(res.mip_gap)
# make sure that the mip_rel_gap parameter is actually doing something
# check that differences between solution gaps are declining
# monotonically with the mip_rel_gap parameter.
assert np.all(np.diff(sol_mip_gaps) < 0)