Python ConcreteModel.y方法代码示例

# 需要导入模块: from pyomo.core import ConcreteModel [as 别名]
# 或者: from pyomo.core.ConcreteModel import y [as 别名]
    def test_indexedvar_noindextemplate(self):
        st_model = CreateConcreteTwoStageScenarioTreeModel(1)
        st_model.StageVariables['Stage1'].add("x")
        st_model.StageDerivedVariables['Stage1'].add("y")
        st_model.NodeVariables['RootNode'].add("z")
        st_model.NodeDerivedVariables['RootNode'].add("q")
        st_model.StageCost['Stage1'] = "FirstStageCost"
        st_model.StageCost['Stage2'] = "SecondStageCost"

        scenario_tree = ScenarioTree(scenariotreeinstance=st_model)
        self.assertEqual(len(scenario_tree.stages), 2)
        self.assertEqual(len(scenario_tree.nodes), 2)
        self.assertEqual(len(scenario_tree.scenarios), 1)

        model = ConcreteModel()
        model.s = Set(initialize=[1,2,3])
        model.x = Var(model.s)
        model.y = Var(model.s)
        model.z = Var(model.s)
        model.q = Var(model.s)
        model.FirstStageCost = Expression(expr=0.0)
        model.SecondStageCost = Expression(expr=0.0)
        model.obj = Objective(expr=0.0)

        scenario_tree.linkInInstances({'Scenario1': model})

        root = scenario_tree.findRootNode()
        self.assertEqual(len(root._variable_ids), 12)
        self.assertEqual(len(root._standard_variable_ids), 6)
        self.assertEqual(len(root._derived_variable_ids), 6)
        for name in ("x", "y", "z", "q"):
            for index in model.s:
                self.assertEqual(
                    (name,index) in root._name_index_to_id, True)

# 需要导入模块: from pyomo.core import ConcreteModel [as 别名]
# 或者: from pyomo.core.ConcreteModel import y [as 别名]
 def test_reciprocal(self):
     m = ConcreteModel()
     m.x = Var(bounds=(1, 2), initialize=1)
     m.y = Var(bounds=(2, 3), initialize=2)
     mc_expr = mc(m.x / m.y)
     self.assertEqual(mc_expr.lower(), 1 / 3)
     self.assertEqual(mc_expr.upper(), 1)

# 需要导入模块: from pyomo.core import ConcreteModel [as 别名]
# 或者: from pyomo.core.ConcreteModel import y [as 别名]
    def test_singletonvar_wildcardtemplate(self):
        st_model = CreateConcreteTwoStageScenarioTreeModel(1)
        st_model.StageVariables['Stage1'].add("x[*]")
        st_model.StageDerivedVariables['Stage1'].add("y[*]")
        st_model.NodeVariables['RootNode'].add("z[*]")
        st_model.NodeDerivedVariables['RootNode'].add("q[*]")
        st_model.StageCost['Stage1'] = "FirstStageCost"
        st_model.StageCost['Stage2'] = "SecondStageCost"

        scenario_tree = ScenarioTree(scenariotreeinstance=st_model)
        self.assertEqual(len(scenario_tree.stages), 2)
        self.assertEqual(len(scenario_tree.nodes), 2)
        self.assertEqual(len(scenario_tree.scenarios), 1)

        model = ConcreteModel()
        model.x = Var()
        model.y = Var()
        model.z = Var()
        model.q = Var()
        model.FirstStageCost = Expression(expr=0.0)
        model.SecondStageCost = Expression(expr=0.0)
        model.obj = Objective(expr=0.0)

        scenario_tree.linkInInstances({'Scenario1': model})

        root = scenario_tree.findRootNode()
        self.assertEqual(len(root._variable_ids), 4)
        self.assertEqual(len(root._standard_variable_ids), 2)
        self.assertEqual(len(root._derived_variable_ids), 2)
        for name in ("x", "y", "z", "q"):
            for index in [None]:
                self.assertEqual(
                    (name,index) in root._name_index_to_id, True)

# 需要导入模块: from pyomo.core import ConcreteModel [as 别名]
# 或者: from pyomo.core.ConcreteModel import y [as 别名]
    def test_clone_without_expression_components(self):
        m = ConcreteModel()
        m.x = Var(initialize=5)
        m.y = Var(initialize=3)
        m.e = Expression(expr=m.x**2 + m.x - 1)

        base = m.x**2 + 1
        test = clone_without_expression_components(base, {})
        self.assertIs(base, test)
        self.assertEqual(base(), test())
        test = clone_without_expression_components(base, {id(m.x): m.y})
        self.assertEqual(3**2+1, test())

        base = m.e
        test = clone_without_expression_components(base, {})
        self.assertIsNot(base, test)
        self.assertEqual(base(), test())
        self.assertIsInstance(base, _ExpressionData)
        self.assertIsInstance(test, EXPR.SumExpression)
        test = clone_without_expression_components(base, {id(m.x): m.y})
        self.assertEqual(3**2+3-1, test())

        base = m.e + m.x
        test = clone_without_expression_components(base, {})
        self.assertIsNot(base, test)
        self.assertEqual(base(), test())
        self.assertIsInstance(base, EXPR.SumExpression)
        self.assertIsInstance(test, EXPR.SumExpression)
        self.assertIsInstance(base.arg(0), _ExpressionData)
        self.assertIsInstance(test.arg(0), EXPR.SumExpression)
        test = clone_without_expression_components(base, {id(m.x): m.y})
        self.assertEqual(3**2+3-1 + 3, test())

# 需要导入模块: from pyomo.core import ConcreteModel [as 别名]
# 或者: from pyomo.core.ConcreteModel import y [as 别名]
 def test_lmtd(self):
     m = ConcreteModel()
     m.x = Var(bounds=(0.1, 500), initialize=33.327)
     m.y = Var(bounds=(0.1, 500), initialize=14.436)
     m.z = Var(bounds=(0, 90), initialize=22.5653)
     mc_expr = mc(m.z - (m.x * m.y * (m.x + m.y) / 2) ** (1/3))
     self.assertAlmostEqual(mc_expr.convex(), -407.95444629965016)
     self.assertAlmostEqual(mc_expr.lower(), -499.99999999999983)

# 需要导入模块: from pyomo.core import ConcreteModel [as 别名]
# 或者: from pyomo.core.ConcreteModel import y [as 别名]
 def test_fixed_var(self):
     m = ConcreteModel()
     m.x = Var(bounds=(-50, 80), initialize=3)
     m.y = Var(bounds=(0, 6), initialize=2)
     m.y.fix()
     mc_expr = mc(m.x * m.y)
     self.assertEqual(mc_expr.lower(), -100)
     self.assertEqual(mc_expr.upper(), 160)

# 需要导入模块: from pyomo.core import ConcreteModel [as 别名]
# 或者: from pyomo.core.ConcreteModel import y [as 别名]
 def test_mc_3d(self):
     m = ConcreteModel()
     m.x = Var(bounds=(-2, 1), initialize=-1)
     m.y = Var(bounds=(-1, 2), initialize=0)
     m.e = Expression(expr=m.x * pow(exp(m.x) - m.y, 2))
     ccSurf, cvSurf, ccAffine, cvAffine = make3dPlot(m.e.expr, 30)
     self.assertAlmostEqual(ccSurf[48], 11.5655473482574)
     self.assertAlmostEqual(cvSurf[48], -15.28102124928224)
     self.assertAlmostEqual(ccAffine[48], 11.565547348257398)
     self.assertAlmostEqual(cvAffine[48], -23.131094696514797)

# 需要导入模块: from pyomo.core import ConcreteModel [as 别名]
# 或者: from pyomo.core.ConcreteModel import y [as 别名]
 def test_fixed_var(self):
     m = ConcreteModel()
     m.x = Var(bounds=(-50, 80), initialize=3)
     m.y = Var(bounds=(0, 6), initialize=2)
     m.y.fix()
     mc_expr = mc(m.x * m.y)
     self.assertEqual(mc_expr.lower(), -100)
     self.assertEqual(mc_expr.upper(), 160)
     self.assertEqual(
         str(mc_expr),
         "[ -1.00000e+02 :  1.60000e+02 ] [  6.00000e+00 :  6.00000e+00 ] [ ( 2.00000e+00) : ( 2.00000e+00) ]")

# 需要导入模块: from pyomo.core import ConcreteModel [as 别名]
# 或者: from pyomo.core.ConcreteModel import y [as 别名]
 def test_trig(self):
     m = ConcreteModel()
     m.x = Var(bounds=(pi / 4, pi / 2), initialize=pi / 4)
     mc_expr = mc(tan(atan((m.x))))
     self.assertAlmostEqual(mc_expr.lower(), pi / 4)
     self.assertAlmostEqual(mc_expr.upper(), pi / 2)
     m.y = Var(bounds=(0, sin(pi / 4)), initialize=0)
     mc_expr = mc(asin((m.y)))
     self.assertEqual(mc_expr.lower(), 0)
     self.assertAlmostEqual(mc_expr.upper(), pi / 4)
     m.z = Var(bounds=(0, cos(pi / 4)), initialize=0)
     mc_expr = mc(acos((m.z)))
     self.assertAlmostEqual(mc_expr.lower(), pi / 4)
     self.assertAlmostEqual(mc_expr.upper(), pi / 2)

# 需要导入模块: from pyomo.core import ConcreteModel [as 别名]
# 或者: from pyomo.core.ConcreteModel import y [as 别名]
 def test_powers(self):
     m = ConcreteModel()
     m.x = Var(bounds=(0, 2), initialize=1)
     m.y = Var(bounds=(1e-4, 2), initialize=1)
     with self.assertRaisesRegexp(MCPP_Error, "Log with negative values in range"):
         mc(m.x ** 1.5)
     mc_expr = mc(m.y ** 1.5)
     self.assertAlmostEqual(mc_expr.lower(), 1e-4**1.5)
     self.assertAlmostEqual(mc_expr.upper(), 2**1.5)
     mc_expr = mc(m.y ** m.x)
     self.assertAlmostEqual(mc_expr.lower(), 1e-4**2)
     self.assertAlmostEqual(mc_expr.upper(), 4)
     m.z = Var(bounds=(-1, 1), initialize=0)
     mc_expr = mc(m.z ** 2)
     self.assertAlmostEqual(mc_expr.lower(), 0)
     self.assertAlmostEqual(mc_expr.upper(), 1)

# 需要导入模块: from pyomo.core import ConcreteModel [as 别名]
# 或者: from pyomo.core.ConcreteModel import y [as 别名]
def makeTwoTermDisj_Nonlinear():
    m = ConcreteModel()
    m.w = Var(bounds=(2, 7))
    m.x = Var(bounds=(1, 8))
    m.y = Var(bounds=(-10, -3))

    def d_rule(disjunct, flag):
        m = disjunct.model()
        if flag:
            disjunct.c1 = Constraint(expr=m.x >= 2)
            disjunct.c2 = Constraint(expr=m.w == 3)
            disjunct.c3 = Constraint(expr=(1, m.x, 3))
        else:
            disjunct.c = Constraint(expr=m.x + m.y**2 <= 14)
    m.d = Disjunct([0, 1], rule=d_rule)
    m.disjunction = Disjunction(expr=[m.d[0], m.d[1]])
    return m

# 需要导入模块: from pyomo.core import ConcreteModel [as 别名]
# 或者: from pyomo.core.ConcreteModel import y [as 别名]
def makeTwoTermDisj_BlockOnDisj():
    m = ConcreteModel()
    m.x = Var(bounds=(0, 1000))
    m.y = Var(bounds=(0, 800))

    def disj_rule(d, flag):
        m = d.model()
        if flag:
            d.b = Block()
            d.b.c = Constraint(expr=m.x == 0)
            d.add_component('b.c', Constraint(expr=m.y >= 9))
            d.b.anotherblock = Block()
            d.b.anotherblock.c = Constraint(expr=m.y >= 11)
            d.bb = Block([1])
            d.bb[1].c = Constraint(expr=m.x == 0)
        else:
            d.c = Constraint(expr=m.x >= 80)
    m.evil = Disjunct([0, 1], rule=disj_rule)
    m.disjunction = Disjunction(expr=[m.evil[0], m.evil[1]])
    return m