def test_method(self):
class Init(object):
def a_init(self, m):
return 0
def x_init(self, m, i):
return i+1
def x2_init(self, m):
return 0
def y_init(self, m, i, j):
return j*(i+1)
init = Init()
m = ConcreteModel()
a = Initializer(init.a_init)
self.assertIs(type(a), ScalarCallInitializer)
self.assertTrue(a.constant())
self.assertFalse(a.verified)
self.assertFalse(a.contains_indices())
self.assertEqual(a(None, 1), 0)
m.x = Var([1,2,3])
a = Initializer(init.x_init)
self.assertIs(type(a), IndexedCallInitializer)
self.assertFalse(a.constant())
self.assertFalse(a.verified)
self.assertFalse(a.contains_indices())
self.assertEqual(a(None, 1), 2)
a = Initializer(init.x2_init)
self.assertIs(type(a), ScalarCallInitializer)
self.assertTrue(a.constant())
self.assertFalse(a.verified)
self.assertFalse(a.contains_indices())
self.assertEqual(a(None, 1), 0)
m.y = Var([1,2,3], [4,5,6])
a = Initializer(init.y_init)
self.assertIs(type(a), IndexedCallInitializer)
self.assertFalse(a.constant())
self.assertFalse(a.verified)
self.assertFalse(a.contains_indices())
self.assertEqual(a(None, (1, 4)), 8)
b = CountedCallInitializer(m.x, a)
self.assertIs(type(b), CountedCallInitializer)
self.assertFalse(b.constant())
self.assertFalse(b.verified)
self.assertFalse(a.contains_indices())
self.assertFalse(b._scalar)
self.assertIs(a._fcn, b._fcn)
c = b(None, 1)
self.assertIs(type(c), CountedCallGenerator)
self.assertEqual(next(c), 2)
self.assertEqual(next(c), 3)
self.assertEqual(next(c), 4)
def test_function(self):
m = ConcreteModel()
def a_init(m):
return 0
a = Initializer(a_init)
self.assertIs(type(a), ScalarCallInitializer)
self.assertFalse(a.constant())
self.assertFalse(a.verified)
self.assertFalse(a.contains_indices())
self.assertEqual(a(None, 1), 0)
m.x = Var([1, 2, 3])
def x_init(m, i):
return i + 1
a = Initializer(x_init)
self.assertIs(type(a), IndexedCallInitializer)
self.assertFalse(a.constant())
self.assertFalse(a.verified)
self.assertFalse(a.contains_indices())
self.assertEqual(a(None, 1), 2)
def x2_init(m):
return 0
a = Initializer(x2_init)
self.assertIs(type(a), ScalarCallInitializer)
self.assertFalse(a.constant())
self.assertFalse(a.verified)
self.assertFalse(a.contains_indices())
self.assertEqual(a(None, 1), 0)
m.y = Var([1, 2, 3], [4, 5, 6])
def y_init(m, i, j):
return j * (i + 1)
a = Initializer(y_init)
self.assertIs(type(a), IndexedCallInitializer)
self.assertFalse(a.constant())
self.assertFalse(a.verified)
self.assertFalse(a.contains_indices())
self.assertEqual(a(None, (1, 4)), 8)
b = CountedCallInitializer(m.x, a)
self.assertIs(type(b), CountedCallInitializer)
self.assertFalse(b.constant())
self.assertFalse(b.verified)
self.assertFalse(a.contains_indices())
self.assertFalse(b._scalar)
self.assertIs(a._fcn, b._fcn)
c = b(None, 1)
self.assertIs(type(c), CountedCallGenerator)
self.assertEqual(next(c), 2)
self.assertEqual(next(c), 3)
self.assertEqual(next(c), 4)
def test_sequence(self):
m = ConcreteModel()
a = Initializer([0,5])
self.assertIs(type(a), ItemInitializer)
self.assertFalse(a.constant())
self.assertFalse(a.verified)
self.assertTrue(a.contains_indices())
self.assertEqual(list(a.indices()), [0,1])
self.assertEqual(a(None, 1), 5)
a = Initializer([0,5], treat_sequences_as_mappings=False)
self.assertIs(type(a), ConstantInitializer)
self.assertTrue(a.constant())
self.assertFalse(a.verified)
self.assertFalse(a.contains_indices())
self.assertEqual(a(None, 1), [0,5])
def test_dict(self):
m = ConcreteModel()
a = Initializer({1:5})
self.assertIs(type(a), ItemInitializer)
self.assertFalse(a.constant())
self.assertFalse(a.verified)
self.assertTrue(a.contains_indices())
self.assertEqual(list(a.indices()), [1])
self.assertEqual(a(None, 1), 5)
def test_constant(self):
m = ConcreteModel()
a = Initializer(5)
self.assertIs(type(a), ConstantInitializer)
self.assertTrue(a.constant())
self.assertFalse(a.verified)
self.assertFalse(a.contains_indices())
with self.assertRaisesRegex(
RuntimeError, "Initializer ConstantInitializer does "
"not contain embedded indices"):
a.indices()
self.assertEqual(a(None, 1), 5)
def test_initializer_initializer(self):
d = {'col1': [1, 2, 4], 'col2': [10, 20, 40]}
df = pd.DataFrame(data=d)
a = Initializer(DataFrameInitializer(df, 'col2'))
self.assertIs(type(a), DataFrameInitializer)
self.assertFalse(a.constant())
self.assertFalse(a.verified)
self.assertTrue(a.contains_indices())
self.assertEqual(list(a.indices()), [0, 1, 2])
self.assertEqual(a(None, 0), 10)
self.assertEqual(a(None, 1), 20)
self.assertEqual(a(None, 2), 40)
def test_dataframe(self):
d = {'col1': [1, 2, 4]}
df = pd.DataFrame(data=d)
a = Initializer(df)
self.assertIs(type(a), DataFrameInitializer)
self.assertFalse(a.constant())
self.assertFalse(a.verified)
self.assertTrue(a.contains_indices())
self.assertEqual(list(a.indices()), [0, 1, 2])
self.assertEqual(a(None, 0), 1)
self.assertEqual(a(None, 1), 2)
self.assertEqual(a(None, 2), 4)
d = {'col1': [1, 2, 4], 'col2': [10, 20, 40]}
df = pd.DataFrame(data=d)
with self.assertRaisesRegex(
ValueError,
'DataFrameInitializer for DataFrame with multiple columns'):
a = Initializer(df)
a = DataFrameInitializer(df, 'col2')
self.assertIs(type(a), DataFrameInitializer)
self.assertFalse(a.constant())
self.assertFalse(a.verified)
self.assertTrue(a.contains_indices())
self.assertEqual(list(a.indices()), [0, 1, 2])
self.assertEqual(a(None, 0), 10)
self.assertEqual(a(None, 1), 20)
self.assertEqual(a(None, 2), 40)
df = pd.DataFrame([10, 20, 30, 40], index=[[0, 0, 1, 1], [0, 1, 0, 1]])
a = Initializer(df)
self.assertIs(type(a), DataFrameInitializer)
self.assertFalse(a.constant())
self.assertFalse(a.verified)
self.assertTrue(a.contains_indices())
self.assertEqual(list(a.indices()), [(0, 0), (0, 1), (1, 0), (1, 1)])
self.assertEqual(a(None, (0, 0)), 10)
self.assertEqual(a(None, (0, 1)), 20)
self.assertEqual(a(None, (1, 0)), 30)
self.assertEqual(a(None, (1, 1)), 40)
def test_config_integration(self):
c = ConfigList()
c.add(1)
c.add(3)
c.add(5)
a = Initializer(c)
self.assertIs(type(a), ItemInitializer)
self.assertTrue(a.contains_indices())
self.assertEqual(list(a.indices()), [0, 1, 2])
self.assertEqual(a(None, 0), 1)
self.assertEqual(a(None, 1), 3)
self.assertEqual(a(None, 2), 5)
c = ConfigDict()
c.declare('opt_1', ConfigValue(default=1))
c.declare('opt_3', ConfigValue(default=3))
c.declare('opt_5', ConfigValue(default=5))
a = Initializer(c)
self.assertIs(type(a), ItemInitializer)
self.assertTrue(a.contains_indices())
self.assertEqual(list(a.indices()), ['opt_1', 'opt_3', 'opt_5'])
self.assertEqual(a(None, 'opt_1'), 1)
self.assertEqual(a(None, 'opt_3'), 3)
self.assertEqual(a(None, 'opt_5'), 5)
def construct(self, data=None):
""" Apply the rule to construct values in this set """
if self._constructed:
return
self._constructed = True
timer = ConstructionTimer(self)
if is_debug_set(logger):
logger.debug("Constructing Expression, name=%s, from data=%s" %
(self.name, str(data)))
rule = self.rule
try:
# We do not (currently) accept data for constructing Constraints
index = None
assert data is None
if rule is None:
# Historically, Expression objects were dense (but None):
rule = Initializer(lambda *args: None)
# If there is no rule, then we are immediately done.
#return
block = self.parent_block()
if rule.contains_indices():
# The index is coming in externally; we need to validate it
for index in rule.indices():
self[index] = rule(block, index)
elif not self.index_set().isfinite():
# If the index is not finite, then we cannot iterate
# over it. Since the rule doesn't provide explicit
# indices, then there is nothing we can do (the
# assumption is that the user will trigger specific
# indices to be created at a later time).
pass
else:
# Bypass the index validation and create the member directly
for index in self.index_set():
self._setitem_when_not_present(index, rule(block, index))
except Exception:
err = sys.exc_info()[1]
logger.error("Rule failed when generating expression for "
"Expression %s with index %s:\n%s: %s" %
(self.name, str(index), type(err).__name__, err))
raise
finally:
timer.report()