Example #1
0
    def _convert_priorities_to_rows(self, instance, priorities, directions):
        if isinstance(instance, IBlock):
            smap = getattr(instance, "._symbol_maps")[self._smap_id]
        else:
            smap = instance.solutions.symbol_map[self._smap_id]
        byObject = smap.byObject

        rows = []
        for var, priority in priorities.items():
            if priority is None or not var.active:
                continue

            if not (0 <= priority == int(priority)):
                raise ValueError("`priority` must be a non-negative integer")

            var_direction = directions.get(var, BranchDirection.default)

            for child_var in iter_component(var):
                if id(child_var) not in byObject:
                    continue

                child_var_direction = directions.get(child_var, var_direction)

                rows.append(
                    (byObject[id(child_var)], priority, child_var_direction))
        return rows
Example #2
0
    def test_iter_component_base(self):
        model = pyo.ConcreteModel()
        model.x = pyo.Var([1, 2, 3], initialize=0)
        model.z = pyo.Var(initialize=0)

        def con_rule(m, i):
            return m.x[i] + m.z == i

        model.con = pyo.Constraint([1, 2, 3], rule=con_rule)
        model.zcon = pyo.Constraint(expr=model.z >= model.x[2])

        self.assertSameComponents(list(iter_component(model.x)),
                                  list(model.x.values()))
        self.assertSameComponents(list(iter_component(model.z)),
                                  [model.z[None]])
        self.assertSameComponents(list(iter_component(model.con)),
                                  list(model.con.values()))
        self.assertSameComponents(list(iter_component(model.zcon)),
                                  [model.zcon[None]])
Example #3
0
    def test_iter_component_kernel(self):
        model = pmo.block()
        model.x = pmo.variable_list(pmo.variable(value=0) for _ in [1, 2, 3])
        model.z = pmo.variable(value=0)

        model.con = pmo.constraint_dict(
            (i, pmo.constraint(expr=model.x[i - 1] + model.z == i))
            for i in [1, 2, 3])
        model.zcon = pmo.constraint(expr=model.z >= model.x[2])

        model.param_t = pmo.parameter_tuple(
            pmo.parameter(value=36) for _ in [1, 2, 3])
        model.param = pmo.parameter(value=42)

        self.assertSameComponents(list(iter_component(model.x)), list(model.x))
        self.assertSameComponents(list(iter_component(model.z)), [model.z])
        self.assertSameComponents(list(iter_component(model.con)),
                                  list(model.con.values()))
        self.assertSameComponents(list(iter_component(model.zcon)),
                                  [model.zcon])
        self.assertSameComponents(list(iter_component(model.param_t)),
                                  list(model.param_t))
        self.assertSameComponents(list(iter_component(model.param)),
                                  [model.param])