def test_range_relational(self):
a = AnyRange()
b = AnyRange()
self.assertTrue(a.issubset(b))
self.assertEqual(a, a)
self.assertEqual(a, b)
c = NR(None, None, 0)
self.assertFalse(a.issubset(c))
self.assertTrue(c.issubset(b))
self.assertNotEqual(a, c)
self.assertNotEqual(c, a)
def test_range_relational(self):
a = NNR('a')
aa = NNR('a')
b = NNR(None)
self.assertTrue(a.issubset(aa))
self.assertFalse(a.issubset(b))
self.assertEqual(a, a)
self.assertEqual(a, aa)
self.assertNotEqual(a, b)
c = NR(None, None, 0)
self.assertFalse(a.issubset(c))
self.assertFalse(c.issubset(b))
self.assertNotEqual(a, c)
self.assertNotEqual(c, a)
def test_range_difference(self):
self.assertEqual(
NR(0, None, 1).range_difference([NR(1, None, 0)]),
[NR(0, 0, 0)],
)
self.assertEqual(
NR(0, None, 1).range_difference([NR(0, 0, 0)]),
[NR(1, None, 1)],
)
self.assertEqual(
NR(0, None, 2).range_difference([NR(10, None, 3)]),
[NR(0, None, 6), NR(2, None, 6),
NR(4, 4, 0)],
)
with self.assertRaisesRegexp(ValueError, "Unknown range type, list"):
NR(0, None, 0).range_difference([[0]])
# test relatively prime ranges that don't expand to all offsets
self.assertEqual(
NR(0, 7, 2).range_difference([NR(6, None, 10)]),
[NR(0, 0, 0), NR(2, 2, 0), NR(4, 4, 0)],
)
# test ranges running in the other direction
self.assertEqual(
NR(10, 0, -1).range_difference([NR(7, 4, -2)]),
[NR(10, 0, -2), NR(1, 3, 2),
NR(9, 9, 0)],
)
self.assertEqual(
NR(0, None, -1).range_difference([NR(-10, 10, 0)]),
[NR(-11, None, -1)],
)
# Test non-overlapping ranges
self.assertEqual(
NR(0, 4, 0).range_difference([NR(5, 10, 0)]),
[NR(0, 4, 0)],
)
self.assertEqual(
NR(5, 10, 0).range_difference([NR(0, 4, 0)]),
[NR(5, 10, 0)],
)
# Test continuous ranges
# Subtracting a closed range from a closed range should
# result in an open range.
self.assertEqual(
NR(0, None, 0).range_difference([NR(5, None, 0)]),
[NR(0, 5, 0, '[)')],
)
self.assertEqual(
NR(0, None, 0).range_difference([NR(5, 10, 0)]),
[NR(0, 5, 0, '[)'), NR(10, None, 0, '(]')],
)
self.assertEqual(
NR(None, 0, 0).range_difference([NR(-5, None, 0)]),
[NR(None, -5, 0, '[)')],
)
self.assertEqual(
NR(None, 0, 0).range_difference([NR(-5, 0, 0, '[)')]),
[NR(None, -5, 0, '[)')],
)
# Subtracting an open range from a closed range gives a closed
# range
self.assertEqual(
NR(0, None, 0).range_difference([NR(5, 10, 0, '()')]),
[NR(0, 5, 0, '[]'), NR(10, None, 0, '[]')],
)
# Subtracting a discrete range from a continuous range gives a
# set of open continuous ranges
self.assertEqual(
NR(None, None, 0).range_difference([NR(5, 10, 5)]),
[NR(None, 5, 0, '[)'),
NR(5, 10, 0, '()'),
NR(10, None, 0, '(]')],
)
self.assertEqual(
NR(-10, 20, 0).range_difference([NR(5, 10, 5)]),
[NR(-10, 5, 0, '[)'),
NR(5, 10, 0, '()'),
NR(10, 20, 0, '(]')],
)
self.assertEqual(
NR(-10, 20, 0, "()").range_difference([NR(5, 10, 5)]),
[NR(-10, 5, 0, '()'),
NR(5, 10, 0, '()'),
NR(10, 20, 0, '()')],
)
self.assertEqual(
NR(-3, 3, 0).range_difference([NR(0, None, 5),
NR(0, None, -5)]),
[NR(-3, 0, 0, '[)'), NR(0, 3, 0, '(]')],
)
# Disjoint ranges...
a = NR(0.25, 10, 1)
self.assertEqual(a.range_difference([NR(0.5, 20, 1)]), [a])
self.assertEqual(a.range_difference(
[NR(0.5, 20,
2)]), [NR(0.25, 8.25, 2), NR(1.25, 9.25, 2)])
a = NR(0, 100, 2)
self.assertEqual(a.range_difference([NR(1, 100, 4)]),
[NR(0, 100, 4), NR(2, 98, 4)])
a = NR(0, None, 2)
self.assertEqual(a.range_difference([NR(1, None, 4)]),
[NR(0, None, 4), NR(2, None, 4)])
a = NR(0.25, None, 1)
self.assertEqual(a.range_difference([NR(0.5, None, 1)]), [a])
def test_range_intersection(self):
self.assertEqual(
NR(0, None, 1).range_intersection([NR(1, None, 0)]),
[NR(1, None, 1)],
)
self.assertEqual(
NR(0, None, 1).range_intersection([NR(0, 0, 0)]),
[NR(0, 0, 0)],
)
self.assertEqual(
NR(0, None, 1).range_intersection([NR(0.5, 1.5, 0)]),
[NR(1, 1, 0)],
)
self.assertEqual(
NR(0, None, 2).range_intersection([NR(1, None, 3)]),
[NR(4, None, 6)],
)
with self.assertRaisesRegexp(ValueError, "Unknown range type, list"):
NR(0, None, 0).range_intersection([[0]])
# Test non-overlapping ranges
self.assertEqual(
NR(0, 4, 0).range_intersection([NR(5, 10, 0)]),
[],
)
self.assertEqual(
NR(5, 10, 0).range_intersection([NR(0, 4, 0)]),
[],
)
# test ranges running in the other direction
self.assertEqual(
NR(10, 0, -1).range_intersection([NR(7, 4, -2)]),
[NR(5, 7, 2)],
)
self.assertEqual(
NR(10, 0, -1).range_intersection([NR(7, None, -2)]),
[NR(1, 7, 2)],
)
self.assertEqual(
NR(0, None, -1).range_intersection([NR(None, -10, 0)]),
[NR(-10, None, -1)],
)
# Test continuous ranges
self.assertEqual(
NR(0, 5, 0).range_intersection([NR(5, 10, 0)]),
[NR(5, 5, 0)],
)
self.assertEqual(
NR(0, None, 0).range_intersection([NR(5, None, 0)]),
[NR(5, None, 0)],
)
# Disjoint ranges...
a = NR(0.25, 10, 1)
self.assertEqual(a.range_intersection([NR(0.5, 20, 1)]), [])
self.assertEqual(a.range_intersection([NR(0.5, 20, 2)]), [])
a = NR(0, 100, 2)
self.assertEqual(a.range_intersection([NR(1, 100, 4)]), [])
a = NR(0, None, 2)
self.assertEqual(a.range_intersection([NR(1, None, 4)]), [])
a = NR(0.25, None, 1)
self.assertEqual(a.range_intersection([NR(0.5, None, 1)]), [])
def _trf_config():
"""
Generate the configuration dictionary.
The user may change the configuration options during the instantiation
of the trustregion solver:
>>> optTRF = SolverFactory('trustregion',
... solver='ipopt',
... maximum_iterations=50,
... minimum_radius=1e-5,
... verbose=True)
The user may also update the configuration after instantiation:
>>> optTRF = SolverFactory('trustregion')
>>> optTRF._CONFIG.trust_radius = 0.5
The user may also update the configuration as part of the solve call:
>>> optTRF = SolverFactory('trustregion')
>>> optTRF.solve(model, decision_variables, trust_radius=0.5)
Returns
-------
CONFIG : ConfigDict
This holds all configuration options to be passed to the TRF solver.
"""
CONFIG = ConfigDict('TrustRegion')
### Solver options
CONFIG.declare(
'solver',
ConfigValue(default='ipopt',
description='Solver to use. Default = ``ipopt``.'))
CONFIG.declare(
'keepfiles',
ConfigValue(default=False,
domain=Bool,
description="Optional. Whether or not to "
"write files of sub-problems for use in debugging. "
"Default = False."))
CONFIG.declare(
'tee',
ConfigValue(default=False,
domain=Bool,
description="Optional. Sets the ``tee`` "
"for sub-solver(s) utilized. "
"Default = False."))
### Trust Region specific options
CONFIG.declare(
'verbose',
ConfigValue(default=False,
domain=Bool,
description="Optional. When True, print each "
"iteration's relevant information to the console "
"as well as to the log. "
"Default = False."))
CONFIG.declare(
'trust_radius',
ConfigValue(default=1.0,
domain=PositiveFloat,
description="Initial trust region radius ``delta_0``. "
"Default = 1.0."))
CONFIG.declare(
'minimum_radius',
ConfigValue(
default=1e-6,
domain=PositiveFloat,
description="Minimum allowed trust region radius ``delta_min``. "
"Default = 1e-6."))
CONFIG.declare(
'maximum_radius',
ConfigValue(
default=CONFIG.trust_radius * 100,
domain=PositiveFloat,
description="Maximum allowed trust region radius. If trust region "
"radius reaches maximum allowed, solver will exit. "
"Default = 100 * trust_radius."))
CONFIG.declare(
'maximum_iterations',
ConfigValue(default=50,
domain=PositiveInt,
description="Maximum allowed number of iterations. "
"Default = 50."))
### Termination options
CONFIG.declare(
'feasibility_termination',
ConfigValue(
default=1e-5,
domain=PositiveFloat,
description=
"Feasibility measure termination tolerance ``epsilon_theta``. "
"Default = 1e-5."))
CONFIG.declare(
'step_size_termination',
ConfigValue(
default=CONFIG.feasibility_termination,
domain=PositiveFloat,
description="Step size termination tolerance ``epsilon_s``. "
"Matches the feasibility termination tolerance by default."))
### Switching Condition options
CONFIG.declare(
'minimum_feasibility',
ConfigValue(default=1e-4,
domain=PositiveFloat,
description="Minimum feasibility measure ``theta_min``. "
"Default = 1e-4."))
CONFIG.declare(
'switch_condition_kappa_theta',
ConfigValue(
default=0.1,
domain=In(NumericRange(0, 1, 0, (False, False))),
description="Switching condition parameter ``kappa_theta``. "
"Contained in open set (0, 1). "
"Default = 0.1."))
CONFIG.declare(
'switch_condition_gamma_s',
ConfigValue(default=2.0,
domain=PositiveFloat,
description="Switching condition parameter ``gamma_s``. "
"Must satisfy: ``gamma_s > 1/(1+mu)`` where ``mu`` "
"is contained in set (0, 1]. "
"Default = 2.0."))
### Trust region update/ratio test parameters
CONFIG.declare(
'radius_update_param_gamma_c',
ConfigValue(
default=0.5,
domain=In(NumericRange(0, 1, 0, (False, False))),
description="Lower trust region update parameter ``gamma_c``. "
"Default = 0.5."))
CONFIG.declare(
'radius_update_param_gamma_e',
ConfigValue(
default=2.5,
domain=In(NumericRange(1, None, 0)),
description="Upper trust region update parameter ``gamma_e``. "
"Default = 2.5."))
CONFIG.declare(
'ratio_test_param_eta_1',
ConfigValue(default=0.05,
domain=In(NumericRange(0, 1, 0, (False, False))),
description="Lower ratio test parameter ``eta_1``. "
"Must satisfy: ``0 < eta_1 <= eta_2 < 1``. "
"Default = 0.05."))
CONFIG.declare(
'ratio_test_param_eta_2',
ConfigValue(default=0.2,
domain=In(NumericRange(0, 1, 0, (False, False))),
description="Lower ratio test parameter ``eta_2``. "
"Must satisfy: ``0 < eta_1 <= eta_2 < 1``. "
"Default = 0.2."))
### Filter
CONFIG.declare(
'maximum_feasibility',
ConfigValue(
default=50.0,
domain=PositiveFloat,
description="Maximum allowable feasibility measure ``theta_max``. "
"Parameter for use in filter method."
"Default = 50.0."))
CONFIG.declare(
'param_filter_gamma_theta',
ConfigValue(
default=0.01,
domain=In(NumericRange(0, 1, 0, (False, False))),
description="Fixed filter parameter ``gamma_theta`` within (0, 1). "
"Default = 0.01"))
CONFIG.declare(
'param_filter_gamma_f',
ConfigValue(
default=0.01,
domain=In(NumericRange(0, 1, 0, (False, False))),
description="Fixed filter parameter ``gamma_f`` within (0, 1). "
"Default = 0.01"))
return CONFIG
