def test_book_sh(self, tname, test_file, base_file):
bname = os.path.basename(test_file)
dir_ = os.path.dirname(test_file)
skip_msg = check_skip('test_' + tname)
if skip_msg:
raise unittest.SkipTest(skip_msg)
# Skip all shell tests on Windows.
if os.name == 'nt':
raise unittest.SkipTest("Shell tests are not runnable on Windows")
cwd = os.getcwd()
os.chdir(dir_)
out_file = os.path.splitext(test_file)[0] + '.out'
with open(out_file, 'w') as f:
_env = os.environ.copy()
_env['PATH'] = os.pathsep.join(
[os.path.dirname(sys.executable), _env['PATH']])
subprocess.run(['bash', bname],
stdout=f,
stderr=f,
cwd=dir_,
env=_env)
os.chdir(cwd)
self.compare_files(out_file, base_file)
os.remove(out_file)
def test_getting_started(self):
try:
import numpy as np
except:
raise unittest.SkipTest('numpy is not available')
opt = appsi.solvers.Cplex()
if not opt.available():
raise unittest.SkipTest('cplex is not available')
getting_started.main(plot=False, n_points=10)
def test_exp(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available')
c_bounds = [(-2.5, 2.8), (0.5, 2.8), (0, 2.8), (1, 2.8), (0.5, 1)]
for cl, cu in c_bounds:
m = pyo.Block(concrete=True)
m.x = pyo.Var()
m.c = pyo.Constraint(
expr=pyo.inequality(body=pyo.exp(m.x), lower=cl, upper=cu))
self.tightener(m)
if pyo.value(m.c.lower) <= 0:
_cl = 1e-6
else:
_cl = pyo.value(m.c.lower)
z = np.linspace(_cl, pyo.value(m.c.upper), 100)
if m.x.lb is None:
xl = -np.inf
else:
xl = pyo.value(m.x.lb)
if m.x.ub is None:
xu = np.inf
else:
xu = pyo.value(m.x.ub)
x = np.log(z)
self.assertTrue(np.all(xl <= x))
self.assertTrue(np.all(xu >= x))
def test_pow2(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available')
x_bounds = [(-2.5, 2.8), (-2.5, -0.5), (0.5, 2.8), (-2.5, 0), (0, 2.8),
(-2.5, -1), (1, 2.8), (-1, -0.5), (0.5, 1)]
c_bounds = [(-2.5, 2.8), (0.5, 2.8), (0, 2.8), (1, 2.8), (0.5, 1)]
for xl, xu in x_bounds:
for cl, cu in c_bounds:
m = pyo.Block(concrete=True)
m.x = pyo.Var(bounds=(xl, xu))
m.y = pyo.Var()
m.c = pyo.Constraint(
expr=pyo.inequality(body=m.y**m.x, lower=cl, upper=cu))
self.tightener(m)
x = np.linspace(pyo.value(m.x.lb) + 1e-6,
pyo.value(m.x.ub),
100,
endpoint=False)
z = np.linspace(pyo.value(m.c.lower) + 1e-6,
pyo.value(m.c.upper),
100,
endpoint=False)
if m.y.lb is None:
yl = -np.inf
else:
yl = m.y.lb
if m.y.ub is None:
yu = np.inf
else:
yu = m.y.ub
y = np.exp(np.split(np.log(np.abs(z)), len(z)) / x)
self.assertTrue(np.all(yl <= y))
self.assertTrue(np.all(yu >= y))
def test_sub1(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available')
x_bounds = [(-2.5, 2.8), (-2.5, -0.5), (0.5, 2.8), (-2.5, 0), (0, 2.8),
(-2.5, -1), (1, 2.8), (-1, -0.5), (0.5, 1)]
c_bounds = [(-2.5, 2.8), (-2.5, -0.5), (0.5, 2.8), (-2.5, 0), (0, 2.8),
(-2.5, -1), (1, 2.8), (-1, -0.5), (0.5, 1)]
for xl, xu in x_bounds:
for cl, cu in c_bounds:
m = pyo.Block(concrete=True)
m.x = pyo.Var(bounds=(xl, xu))
m.y = pyo.Var()
m.c = pyo.Constraint(
expr=pyo.inequality(body=m.x - m.y, lower=cl, upper=cu))
self.tightener(m)
x = np.linspace(pyo.value(m.x.lb), pyo.value(m.x.ub), 100)
z = np.linspace(pyo.value(m.c.lower), pyo.value(m.c.upper),
100)
if m.y.lb is None:
yl = -np.inf
else:
yl = m.y.lb
if m.y.ub is None:
yu = np.inf
else:
yu = m.y.ub
for _x in x:
_y = _x - z
self.assertTrue(np.all(yl <= _y))
self.assertTrue(np.all(yu >= _y))
def test_pow4(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available')
y_bounds = [(0.5, 2.8), (0, 2.8), (1, 2.8), (0.5, 1), (0, 0.5)]
exp_vals = [-3, -2.5, -2, -1.5, -1, -0.5, 0.5, 1, 1.5, 2, 2.5, 3]
for yl, yu in y_bounds:
for _exp_val in exp_vals:
m = pyo.Block(concrete=True)
m.x = pyo.Var()
m.y = pyo.Var(bounds=(yl, yu))
m.c = pyo.Constraint(expr=m.x**_exp_val == m.y)
self.tightener(m)
y = np.linspace(pyo.value(m.y.lb) + 1e-6,
pyo.value(m.y.ub),
100,
endpoint=True)
if m.x.lb is None:
xl = -np.inf
else:
xl = m.x.lb
if m.x.ub is None:
xu = np.inf
else:
xu = m.x.ub
_x = np.exp(np.log(y) / _exp_val)
self.assertTrue(np.all(xl <= _x))
self.assertTrue(np.all(xu >= _x))
def test_pow1(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available')
x_bounds = [(0, 2.8), (0.5, 2.8), (1, 2.8), (0.5, 1)]
c_bounds = [(-2.5, 2.8), (0.5, 2.8), (-2.5, 0), (0, 2.8), (1, 2.8), (0.5, 1)]
for xl, xu in x_bounds:
for cl, cu in c_bounds:
m = pyo.Block(concrete=True)
m.x = pyo.Var(bounds=(xl, xu))
m.y = pyo.Var()
m.c = pyo.Constraint(expr=pyo.inequality(body=m.x**m.y, lower=cl, upper=cu))
if xl > 0 and cu <= 0:
with self.assertRaises(InfeasibleConstraintException):
self.tightener(m)
else:
self.tightener(m)
x = np.linspace(pyo.value(m.x.lb) + 1e-6, pyo.value(m.x.ub), 100, endpoint=False)
z = np.linspace(pyo.value(m.c.lower) + 1e-6, pyo.value(m.c.upper), 100, endpoint=False)
if m.y.lb is None:
yl = -np.inf
else:
yl = m.y.lb
if m.y.ub is None:
yu = np.inf
else:
yu = m.y.ub
for _x in x:
_y = np.log(abs(z)) / np.log(abs(_x))
self.assertTrue(np.all(yl <= _y))
self.assertTrue(np.all(yu >= _y))
def test_log10(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available')
c_bounds = [(-2.5, 2.8), (-2.5, -0.5), (0.5, 2.8), (-2.5, 0), (0, 2.8),
(-2.5, -1), (1, 2.8), (-1, -0.5), (0.5, 1)]
for cl, cu in c_bounds:
m = pyo.Block(concrete=True)
m.x = pyo.Var()
m.c = pyo.Constraint(
expr=pyo.inequality(body=pyo.log10(m.x), lower=cl, upper=cu))
self.tightener(m)
z = np.linspace(pyo.value(m.c.lower), pyo.value(m.c.upper), 100)
if m.x.lb is None:
xl = -np.inf
else:
xl = pyo.value(m.x.lb)
if m.x.ub is None:
xu = np.inf
else:
xu = pyo.value(m.x.ub)
x = 10**z
print(xl, xu, cl, cu)
print(x)
self.assertTrue(np.all(xl <= x))
self.assertTrue(np.all(xu >= x))
def test_mutable_param_with_range(self, name: str, opt_class: Type[Solver]):
opt: Solver = opt_class()
if not opt.available():
raise unittest.SkipTest
try:
import numpy as np
except:
raise unittest.SkipTest('numpy is not available')
m = pe.ConcreteModel()
m.x = pe.Var()
m.y = pe.Var()
m.a1 = pe.Param(initialize=0, mutable=True)
m.a2 = pe.Param(initialize=0, mutable=True)
m.b1 = pe.Param(initialize=0, mutable=True)
m.b2 = pe.Param(initialize=0, mutable=True)
m.c1 = pe.Param(initialize=0, mutable=True)
m.c2 = pe.Param(initialize=0, mutable=True)
m.obj = pe.Objective(expr=m.y)
m.con1 = pe.Constraint(expr=(m.b1, m.y - m.a1 * m.x, m.c1))
m.con2 = pe.Constraint(expr=(m.b2, m.y - m.a2 * m.x, m.c2))
np.random.seed(0)
params_to_test = [(np.random.uniform(0, 10), np.random.uniform(-10, 0),
np.random.uniform(-5, 2.5), np.random.uniform(-5, 2.5),
np.random.uniform(2.5, 10), np.random.uniform(2.5, 10), pe.minimize),
(np.random.uniform(0, 10), np.random.uniform(-10, 0),
np.random.uniform(-5, 2.5), np.random.uniform(-5, 2.5),
np.random.uniform(2.5, 10), np.random.uniform(2.5, 10), pe.maximize),
(np.random.uniform(0, 10), np.random.uniform(-10, 0),
np.random.uniform(-5, 2.5), np.random.uniform(-5, 2.5),
np.random.uniform(2.5, 10), np.random.uniform(2.5, 10), pe.minimize),
(np.random.uniform(0, 10), np.random.uniform(-10, 0),
np.random.uniform(-5, 2.5), np.random.uniform(-5, 2.5),
np.random.uniform(2.5, 10), np.random.uniform(2.5, 10), pe.maximize)]
for (a1, a2, b1, b2, c1, c2, sense) in params_to_test:
m.a1.value = float(a1)
m.a2.value = float(a2)
m.b1.value = float(b1)
m.b2.value = float(b2)
m.c1.value = float(c1)
m.c2.value = float(c2)
m.obj.sense = sense
res: Results = opt.solve(m)
self.assertEqual(res.termination_condition, TerminationCondition.optimal)
if sense is pe.minimize:
self.assertAlmostEqual(m.x.value, (b2 - b1) / (a1 - a2), 6)
self.assertAlmostEqual(m.y.value, a1 * (b2 - b1) / (a1 - a2) + b1, 6)
self.assertAlmostEqual(res.best_feasible_objective, m.y.value, 6)
self.assertTrue(res.best_objective_bound <= m.y.value + 1e-12)
duals = opt.get_duals()
self.assertAlmostEqual(duals[m.con1], (1 + a1 / (a2 - a1)), 6)
self.assertAlmostEqual(duals[m.con2], -a1 / (a2 - a1), 6)
else:
self.assertAlmostEqual(m.x.value, (c2 - c1) / (a1 - a2), 6)
self.assertAlmostEqual(m.y.value, a1 * (c2 - c1) / (a1 - a2) + c1, 6)
self.assertAlmostEqual(res.best_feasible_objective, m.y.value, 6)
self.assertTrue(res.best_objective_bound >= m.y.value - 1e-12)
duals = opt.get_duals()
self.assertAlmostEqual(duals[m.con1], (1 + a1 / (a2 - a1)), 6)
self.assertAlmostEqual(duals[m.con2], -a1 / (a2 - a1), 6)
def test_acos(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available.')
yl, yu = self.acos(-0.5, 0.5, -interval.inf, interval.inf, 1e-8)
self.assertEqual(yl, -interval.inf)
self.assertEqual(yu, interval.inf)
yl, yu = self.acos(-0.5, 0.5, -0.5 * math.pi, 0.5 * math.pi, 1e-8)
self.assertAlmostEqual(yl, -0.5 * math.pi, 12)
self.assertAlmostEqual(yu, 0.5 * math.pi, 12)
yl, yu = self.acos(-0.5, 0.5, 0, math.pi, 1e-8)
self.assertAlmostEqual(yl, math.acos(0.5))
self.assertAlmostEqual(yu, math.acos(-0.5))
yl, yu = self.acos(-0.5, 0.5, 0 - 0.1, math.pi + 0.1, 1e-8)
self.assertAlmostEqual(yl, math.acos(0.5))
self.assertAlmostEqual(yu, math.acos(-0.5))
yl, yu = self.acos(-0.5, 0.5, 0 + 0.1, math.pi - 0.1, 1e-8)
self.assertAlmostEqual(yl, math.acos(0.5))
self.assertAlmostEqual(yu, math.acos(-0.5))
yl, yu = self.acos(-0.5, 0.5, -math.pi, 0, 1e-8)
self.assertAlmostEqual(yl, -math.acos(-0.5), 12)
self.assertAlmostEqual(yu, -math.acos(0.5), 12)
yl, yu = self.acos(-0.5, 0.5, -math.pi - 0.1, 0 + 0.1, 1e-8)
self.assertAlmostEqual(yl, -math.acos(-0.5), 12)
self.assertAlmostEqual(yu, -math.acos(0.5), 12)
yl, yu = self.acos(-0.5, 0.5, -math.pi + 0.1, 0 - 0.1, 1e-8)
self.assertAlmostEqual(yl, -math.acos(-0.5), 12)
self.assertAlmostEqual(yu, -math.acos(0.5), 12)
def test_asin(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available.')
yl, yu = self.asin(-0.5, 0.5, -interval.inf, interval.inf, 1e-8)
self.assertEqual(yl, -interval.inf)
self.assertEqual(yu, interval.inf)
yl, yu = self.asin(-0.5, 0.5, -math.pi, math.pi, 1e-8)
self.assertAlmostEqual(yl, -math.pi, 12)
self.assertAlmostEqual(yu, math.pi, 12)
yl, yu = self.asin(-0.5, 0.5, -math.pi / 2, math.pi / 2, 1e-8)
self.assertAlmostEqual(yl, math.asin(-0.5))
self.assertAlmostEqual(yu, math.asin(0.5))
yl, yu = self.asin(-0.5, 0.5, -math.pi / 2 - 0.1, math.pi / 2 + 0.1,
1e-8)
self.assertAlmostEqual(yl, math.asin(-0.5))
self.assertAlmostEqual(yu, math.asin(0.5))
yl, yu = self.asin(-0.5, 0.5, -math.pi / 2 + 0.1, math.pi / 2 - 0.1,
1e-8)
self.assertAlmostEqual(yl, math.asin(-0.5))
self.assertAlmostEqual(yu, math.asin(0.5))
yl, yu = self.asin(-0.5, 0.5, -1.5 * math.pi, 1.5 * math.pi, 1e-8)
self.assertAlmostEqual(yl, -3.6651914291880920, 12)
self.assertAlmostEqual(yu, 3.6651914291880920, 12)
yl, yu = self.asin(-0.5, 0.5, -1.5 * math.pi - 0.1,
1.5 * math.pi + 0.1, 1e-8)
self.assertAlmostEqual(yl, -3.6651914291880920, 12)
self.assertAlmostEqual(yu, 3.6651914291880920, 12)
yl, yu = self.asin(-0.5, 0.5, -1.5 * math.pi + 0.1,
1.5 * math.pi - 0.1, 1e-8)
self.assertAlmostEqual(yl, -3.6651914291880920, 12)
self.assertAlmostEqual(yu, 3.6651914291880920, 12)
def test_exp(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available.')
xl = -2.5
xu = 2.8
zl, zu = self.exp(xl, xu)
x = np.linspace(xl, xu, 100)
_z = np.exp(x)
self.assertTrue(np.all(zl <= _z))
self.assertTrue(np.all(zu >= _z))
def test_log(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available.')
x_bounds = [(np.random.uniform(0, 2), np.random.uniform(2, 5)),
(0, np.random.uniform(2, 5)), (0, 0)]
for xl, xu in x_bounds:
zl, zu = self.log(xl, xu)
x = np.linspace(xl, xu, 100)
_z = np.log(x)
self.assertTrue(np.all(zl <= _z))
self.assertTrue(np.all(zu >= _z))
def test_tan(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available.')
lbs = np.linspace(-2 * math.pi, 2 * math.pi, 10)
ubs = np.linspace(-2 * math.pi, 2 * math.pi, 10)
for xl in lbs:
for xu in ubs:
if xu >= xl:
zl, zu = self.tan(xl, xu)
x = np.linspace(xl, xu, 100)
_z = np.tan(x)
self.assertTrue(np.all(zl <= _z + 1e-14))
self.assertTrue(np.all(zu >= _z - 1e-14))
def test_mul(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available.')
xl = -2.5
xu = 2.8
yl = -3.2
yu = 2.7
zl, zu = self.mul(xl, xu, yl, yu)
x = np.linspace(xl, xu, 100)
y = np.linspace(yl, yu, 100)
for _x in x:
_z = _x * y
self.assertTrue(np.all(zl <= _z))
self.assertTrue(np.all(zu >= _z))
def get_solution(self):
try:
import numpy as np
except:
raise unittest.SkipTest('numpy is not available')
p1 = self.m.p1.value
p2 = self.m.p2.value
p3 = self.m.p3.value
p4 = self.m.p4.value
A = np.array([[1, -p1], [1, -p3]])
rhs = np.array([p2, p4])
sol = np.linalg.solve(A, rhs)
x = float(sol[1])
y = float(sol[0])
return x, y
def test_atan(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available.')
yl, yu = self.atan(-0.5, 0.5, -interval.inf, interval.inf)
self.assertEqual(yl, -interval.inf)
self.assertEqual(yu, interval.inf)
yl, yu = self.atan(-0.5, 0.5, -0.1, 0.1)
self.assertAlmostEqual(yl, -0.1, 12)
self.assertAlmostEqual(yu, 0.1, 12)
yl, yu = self.atan(-0.5, 0.5, -0.5 * math.pi + 0.1, math.pi / 2 - 0.1)
self.assertAlmostEqual(yl, math.atan(-0.5), 12)
self.assertAlmostEqual(yu, math.atan(0.5), 12)
yl, yu = self.atan(-0.5, 0.5, -1.5 * math.pi + 0.1,
1.5 * math.pi - 0.1)
self.assertAlmostEqual(yl, math.atan(-0.5) - math.pi, 12)
self.assertAlmostEqual(yu, math.atan(0.5) + math.pi, 12)
def test_book_py(self, tname, test_file, base_file):
bname = os.path.basename(test_file)
dir_ = os.path.dirname(test_file)
skip_msg = check_skip('test_'+tname)
if skip_msg:
raise unittest.SkipTest(skip_msg)
cwd = os.getcwd()
os.chdir(dir_)
out_file = os.path.splitext(test_file)[0]+'.out'
with open(out_file, 'w') as f:
subprocess.run([sys.executable, bname], stdout=f, stderr=f, cwd=dir_)
os.chdir(cwd)
self.compare_files(out_file, base_file)
os.remove(out_file)
def test_div(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available.')
x_bounds = [(np.random.uniform(-5, -2), np.random.uniform(2, 5))]
y_bounds = [(np.random.uniform(-5, -2), np.random.uniform(2, 5)),
(0, np.random.uniform(2, 5)),
(np.random.uniform(0, 2), np.random.uniform(2, 5)),
(np.random.uniform(-5, -2), 0),
(np.random.uniform(-5, -2), np.random.uniform(-2, 0))]
for xl, xu in x_bounds:
for yl, yu in y_bounds:
zl, zu = self.div(xl, xu, yl, yu, 1e-8)
x = np.linspace(xl, xu, 100)
y = np.linspace(yl, yu, 100)
for _x in x:
_z = _x / y
self.assertTrue(np.all(zl <= _z))
self.assertTrue(np.all(zu >= _z))
def test_pow2(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available.')
xl = np.linspace(-2, 2, 9)
xu = np.linspace(-2, 2, 9)
yl = np.linspace(-2, 2, 9)
yu = np.linspace(-2, 2, 9)
for _xl in xl:
for _xu in xu:
if _xl > _xu:
continue
for _yl in yl:
for _yu in yu:
if _yl > _yu:
continue
if _xl == 0 and _xu == 0 and _yu < 0:
lb, ub = self.power(_xl, _xu, _yl, _yu, 1e-8)
self.assertEqual(lb, -interval.inf)
self.assertEqual(ub, interval.inf)
elif _yl == _yu and _yl != round(_yl) and (
_xu < 0 or (_xu < 0 and _yu < 0)):
with self.assertRaises(
(InfeasibleConstraintException,
interval.IntervalException)):
lb, ub = self.power(_xl, _xu, _yl, _yu, 1e-8)
else:
lb, ub = self.power(_xl, _xu, _yl, _yu, 1e-8)
if isfinite(lb) and isfinite(ub):
nan_fill = 0.5 * (lb + ub)
elif isfinite(lb):
nan_fill = lb + 1
elif isfinite(ub):
nan_fill = ub - 1
else:
nan_fill = 0
x = np.linspace(_xl, _xu, 30)
y = np.linspace(_yl, _yu, 30)
z = x**np.split(y, len(y))
z[np.isnan(z)] = nan_fill
all_values = z
estimated_lb = all_values.min()
estimated_ub = all_values.max()
self.assertTrue(lb - 1e-8 <= estimated_lb)
self.assertTrue(ub + 1e-8 >= estimated_ub)
def test_skip_unknown_expression1(self):
if self.tightener is not fbbt:
raise unittest.SkipTest('Appsi FBBT does not support unkown expressions yet')
m = pyo.ConcreteModel()
m.x = pyo.Var(bounds=(1,1))
m.y = pyo.Var()
expr = DummyExpr([m.x, m.y])
m.c = pyo.Constraint(expr=expr == 1)
OUT = StringIO()
with LoggingIntercept(OUT, 'pyomo.contrib.fbbt.fbbt'):
new_bounds = self.tightener(m)
self.assertEqual(pyo.value(m.x.lb), 1)
self.assertEqual(pyo.value(m.x.ub), 1)
self.assertEqual(pyo.value(m.y.lb), None)
self.assertEqual(pyo.value(m.y.ub), None)
self.assertIn("Unsupported expression type for FBBT", OUT.getvalue())
def test_skip_unknown_expression2(self):
if self.tightener is not fbbt:
raise unittest.SkipTest('Appsi FBBT does not support unkown expressions yet')
def dummy_unary_expr(x):
return 0.5*x
m = pyo.ConcreteModel()
m.x = pyo.Var(bounds=(0,4))
expr = UnaryFunctionExpression((m.x,), name='dummy_unary_expr', fcn=dummy_unary_expr)
m.c = pyo.Constraint(expr=expr == 1)
OUT = StringIO()
with LoggingIntercept(OUT, 'pyomo.contrib.fbbt.fbbt'):
new_bounds = self.tightener(m)
self.assertEqual(pyo.value(m.x.lb), 0)
self.assertEqual(pyo.value(m.x.ub), 4)
self.assertIn("Unsupported expression type for FBBT", OUT.getvalue())
def test_pow(self):
if not numpy_available:
raise unittest.SkipTest('Numpy is not available.')
x_bounds = [(np.random.uniform(0, 2), np.random.uniform(2, 5)),
(0, np.random.uniform(2, 5)), (0, 0)]
y_bounds = [(np.random.uniform(-5, -2), np.random.uniform(2, 5)),
(0, np.random.uniform(2, 5)),
(np.random.uniform(0, 2), np.random.uniform(2, 5)),
(np.random.uniform(-5, -2), 0),
(np.random.uniform(-5, -2), np.random.uniform(-2, 0))]
for xl, xu in x_bounds:
for yl, yu in y_bounds:
zl, zu = self.power(xl, xu, yl, yu, 1e-8)
if xl == 0 and xu == 0 and yu < 0:
self.assertEqual(zl, -interval.inf)
self.assertEqual(zu, interval.inf)
x = np.linspace(xl, xu, 100)
y = np.linspace(yl, yu, 100)
for _x in x:
_z = _x**y
self.assertTrue(np.all(zl <= _z))
self.assertTrue(np.all(zu >= _z))
x_bounds = [(np.random.uniform(-5, -2), np.random.uniform(2, 5)),
(np.random.uniform(-5, -2), np.random.uniform(-2, 0)),
(np.random.uniform(-5, -2), 0)]
y_bounds = list(range(-4, 4))
for xl, xu in x_bounds:
for yl in y_bounds:
yu = yl
zl, zu = self.power(xl, xu, yl, yu, 1e-8)
x = np.linspace(xl, xu, 100, endpoint=False)
y = yl
_z = x**y
self.assertTrue(np.all(zl <= _z))
self.assertTrue(np.all(zu >= _z))
# Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
# rights in this software.
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
import os
import pyomo.common.unittest as unittest
import pyomo.environ as pyo
import math
from pyomo.contrib.pynumero.dependencies import (numpy as np, numpy_available,
scipy, scipy_available)
from pyomo.common.dependencies.scipy import sparse as spa
if not (numpy_available and scipy_available):
raise unittest.SkipTest("Pynumero needs scipy and numpy to run NLP tests")
from pyomo.contrib.pynumero.asl import AmplInterface
if not AmplInterface.available():
raise unittest.SkipTest(
"Pynumero needs the ASL extension to run CyIpoptSolver tests")
from pyomo.contrib.pynumero.algorithms.solvers.cyipopt_solver import (
CyIpoptSolver,
CyIpoptNLP,
cyipopt_available,
)
from pyomo.contrib.pynumero.interfaces.external_grey_box import ExternalGreyBoxModel, ExternalGreyBoxBlock
from pyomo.contrib.pynumero.interfaces.pyomo_nlp import PyomoGreyBoxNLP, PyomoNLP
from pyomo.contrib.pynumero.interfaces.pyomo_grey_box_nlp import PyomoNLPWithGreyBoxBlocks
# ___________________________________________________________________________
#
# Pyomo: Python Optimization Modeling Objects
# Copyright 2017 National Technology and Engineering Solutions of Sandia, LLC
# Under the terms of Contract DE-NA0003525 with National Technology and
# Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
# rights in this software.
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
import pyomo.common.unittest as unittest
from pyomo.contrib.pynumero.dependencies import (numpy as np, numpy_available,
scipy, scipy_available)
if not (numpy_available and scipy_available):
raise unittest.SkipTest("Pynumero needs scipy and numpy to run NLP tests")
import pyomo.contrib.pynumero.interfaces.utils as utils
class TestCondensedSparseSummation(unittest.TestCase):
def test_condensed_sparse_summation(self):
data = [1.0, 0.0]
row = [1, 2]
col = [2, 2]
A = scipy.sparse.coo_matrix((data, (row, col)), shape=(3, 3))
data = [3.0, 0.0]
B = scipy.sparse.coo_matrix((data, (row, col)), shape=(3, 3))
# By default, scipy will remove structural nonzeros that
# have zero values
# National Technology and Engineering Solutions of Sandia, LLC
# Under the terms of Contract DE-NA0003525 with National Technology and
# Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
# rights in this software.
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
import pyomo.common.unittest as unittest
import pyomo.environ as pyo
from pyomo.common.dependencies import attempt_import
np, numpy_available = attempt_import('numpy', 'Interior point requires numpy', minimum_version='1.13.0')
scipy, scipy_available = attempt_import('scipy', 'Interior point requires scipy')
mumps, mumps_available = attempt_import('mumps', 'Interior point requires mumps')
if not (numpy_available and scipy_available):
raise unittest.SkipTest('Interior point tests require numpy and scipy')
if scipy_available:
from pyomo.contrib.interior_point.linalg.scipy_interface import ScipyInterface
if mumps_available:
from pyomo.contrib.interior_point.linalg.mumps_interface import MumpsInterface
import numpy as np
from pyomo.contrib.pynumero.asl import AmplInterface
asl_available = AmplInterface.available()
from pyomo.contrib.interior_point.interior_point import (process_init,
process_init_duals_lb,
process_init_duals_ub,
_fraction_to_the_boundary_helper_lb,
# Copyright 2017 National Technology and Engineering Solutions of Sandia, LLC
# Under the terms of Contract DE-NA0003525 with National Technology and
# Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
# rights in this software.
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
import itertools
import pyomo.common.unittest as unittest
import pyomo.environ as pyo
from pyomo.contrib.pynumero.dependencies import (numpy as np, numpy_available,
scipy, scipy_available)
if not (numpy_available and scipy_available):
raise unittest.SkipTest("Pynumero needs scipy and numpy to run NLP tests")
from pyomo.common.dependencies.scipy import sparse as sps
from pyomo.contrib.pynumero.asl import AmplInterface
if not AmplInterface.available():
raise unittest.SkipTest(
"Pynumero needs the ASL extension to run cyipopt tests")
from pyomo.contrib.pynumero.algorithms.solvers.cyipopt_solver import (
cyipopt_available, )
from pyomo.contrib.pynumero.interfaces.external_pyomo_model import (
ExternalPyomoModel,
get_hessian_of_constraint,
)
from pyomo.contrib.pynumero.interfaces.pyomo_grey_box_nlp import (
# ___________________________________________________________________________
#
# Pyomo: Python Optimization Modeling Objects
# Copyright (c) 2008-2022
# National Technology and Engineering Solutions of Sandia, LLC
# Under the terms of Contract DE-NA0003525 with National Technology and
# Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
# rights in this software.
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
import pyomo.common.unittest as unittest
from pyomo.contrib.pynumero.dependencies import numpy as np, numpy_available
if not numpy_available:
raise unittest.SkipTest('pynumero MA27 tests require numpy')
import ctypes
from pyomo.contrib.pynumero.linalg.ma27 import MA27Interface
@unittest.skipIf(not MA27Interface.available(), reason='MA27 not available')
class TestMA27Interface(unittest.TestCase):
def test_get_cntl(self):
ma27 = MA27Interface()
self.assertEqual(ma27.get_icntl(1), 6)
self.assertAlmostEqual(ma27.get_cntl(1),
1e-1) # Numerical pivot threshold
self.assertAlmostEqual(ma27.get_cntl(3), 0.0) # Null pivot threshold
def test_set_icntl(self):
ma27 = MA27Interface()
ma27.set_icntl(5, 4) # Set output printing to max verbosity
import pyomo.common.unittest as unittest
import filecmp
import glob
import os
import os.path
import subprocess
import sys
from itertools import zip_longest
from pyomo.opt import check_available_solvers
from pyomo.common.dependencies import attempt_import, check_min_version
from pyomo.common.fileutils import this_file_dir
from pyomo.common.tee import capture_output
parameterized, param_available = attempt_import('parameterized')
if not param_available:
raise unittest.SkipTest('Parameterized is not available.')
# Find all *.txt files, and use them to define baseline tests
currdir = this_file_dir()
datadir = currdir
solver_dependencies = {
# abstract_ch
'test_abstract_ch_wl_abstract_script': ['glpk'],
'test_abstract_ch_pyomo_wl_abstract': ['glpk'],
'test_abstract_ch_pyomo_solve1': ['glpk'],
'test_abstract_ch_pyomo_solve2': ['glpk'],
'test_abstract_ch_pyomo_solve3': ['glpk'],
'test_abstract_ch_pyomo_solve4': ['glpk'],
'test_abstract_ch_pyomo_solve5': ['glpk'],
'test_abstract_ch_pyomo_diet1': ['glpk'],
import pyomo.common.unittest as unittest
from pyomo.common.dependencies import attempt_import
np, np_available = attempt_import('numpy', minimum_version='1.13.0')
scipy, scipy_available = attempt_import('scipy.sparse')
mumps, mumps_available = attempt_import('mumps')
if not np_available or not scipy_available:
raise unittest.SkipTest(
'numpy and scipy are needed for interior point tests')
import numpy as np
from scipy.sparse import coo_matrix, tril
from pyomo.contrib import interior_point as ip
from pyomo.contrib.pynumero.linalg.base import LinearSolverStatus
if scipy_available:
from pyomo.contrib.interior_point.linalg.scipy_interface import ScipyInterface
if mumps_available:
from pyomo.contrib.interior_point.linalg.mumps_interface import MumpsInterface
from pyomo.contrib.pynumero.linalg.ma27 import MA27Interface
ma27_available = MA27Interface.available()
if ma27_available:
from pyomo.contrib.interior_point.linalg.ma27_interface import InteriorPointMA27Interface
def get_base_matrix(use_tril):
if use_tril:
row = [0, 1, 1, 2, 2]
col = [0, 0, 1, 0, 2]
data = [1, 7, 4, 3, 6]
else:
row = [0, 0, 0, 1, 1, 2, 2]
col = [0, 1, 2, 0, 1, 0, 2]
data = [1, 7, 3, 7, 4, 3, 6]
