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