Python LP.getIndexBlock方法代码示例

# 需要导入模块: from pylpsolve import LP [as 别名]
# 或者: from pylpsolve.LP import getIndexBlock [as 别名]
    def checkLBUBMix(self, opts, lb, ub):

        # these are indices to bound
        lbindices = (0,3)

        ubindices = {}
        ubindices["t"] = (3,6)
        ubindices["n"] = "a"
        ubindices["N"] = "a"
        ubindices["l"] = [3,4,5]
        ubindices["a"] = ar([3,4,5],dtype=uint)
        ubindices["f"] = ar([3,4,5],dtype=float64)

        ubvalues = {}
        ubvalues["s"] = ub
        ubvalues["l"] = [ub, ub, ub]
        ubvalues["a"] = ar([ub, ub, ub])

        lbvalues = {}
        lbvalues["s"] = lb
        lbvalues["l"] = [lb, lb, lb]
        lbvalues["a"] = ar([lb, lb, lb])

        lp = LP()

        lp.setLowerBound(lbindices, lbvalues[opts[1]])

        if opts[0] == "N":
            lp.getIndexBlock(ubindices["N"], 3)

        lp.setUpperBound(ubindices[opts[0]], ubvalues[opts[1]])

        lp.setObjective([1,1,1,-1,-1,-1])


        for num_times in range(2):  # make sure it's same anser second time
            lp.solve()

            self.assertAlmostEqual(lp.getObjectiveValue(), lb*3 - ub*3)

            v = lp.getSolution()

            self.assert_(len(v) == 6)
            self.assertAlmostEqual(v[0], lb)
            self.assertAlmostEqual(v[1], lb)
            self.assertAlmostEqual(v[2], lb)

            self.assertAlmostEqual(v[3], ub)
            self.assertAlmostEqual(v[4], ub)
            self.assertAlmostEqual(v[5], ub)

# 需要导入模块: from pylpsolve import LP [as 别名]
# 或者: from pylpsolve.LP import getIndexBlock [as 别名]
    def checkInconsistentSubarrays(self, opts):

        values = {}

        indices = {}
        indices["t"] = (0,3)
        indices["n"] = "a"
        indices["N"] = "a"
        indices["l"] = [0,1,2]
        indices["a"] = ar([0,1,2],dtype=uint)
        indices["f"] = ar([0,1,2],dtype=float64)
        indices["e"] = None  # empty

        A = [[1,0,  0],
             [0,1],      # inconsistent; does this get caught?
             [0,0.5,0]]

        values = {}
        values["L"] = A
        values["l"] = [ar(le) for le in A]
        values["B"] = [[1, 0, 0], [[1,0,0]], [0,1,1]]
        values["C"] = ones((1,3,3) )
        values["D"] = [[1, 0, 0], [1,1,[1]], [0,1,1]]
        values["E"] = [[1, 0, 0], (1,1,1), [0,1,1]]

        targets = {}
        targets["s"] = 1
        targets["l"] = [1,1,1]
        targets["a"] = ar([1,1,1],dtype=uint)
        targets["f"] = ar([1,1,1],dtype=float64)

        lp = LP()

        if opts[0] == "N":
            lp.getIndexBlock(indices["N"], 3)

        io = indices[opts[0]]
        vl = values [opts[1]]
        tr = targets[opts[2]]
        ob = [1,2,3]
        
        if io is None:
            self.assertRaises(ValueError, lambda: lp.addConstraint(vl, ">=", tr))
        else:
            self.assertRaises(ValueError, lambda: lp.addConstraint( (io, vl), ">=", tr))

# 需要导入模块: from pylpsolve import LP [as 别名]
# 或者: from pylpsolve.LP import getIndexBlock [as 别名]
    def checkUB(self, opts, ub):

        # these are indices to bound
        indices = {}
        indices["t"] = (0,3)
        indices["N"] = "a"
        indices["l"] = [0,1,2]
        indices["a"] = ar([0,1,2],dtype=uint)
        indices["f"] = ar([0,1,2],dtype=float64)

        ubvalues = {}
        ubvalues["s"] = ub
        ubvalues["l"] = [ub, ub, ub]
        ubvalues["a"] = ar([ub, ub, ub])

        lp = LP()

        if opts[0] == "N":
            lp.getIndexBlock(indices["N"], 3)

        lp.setObjective([1,1,1,1,1,1])
        lp.addConstraint( ((3,6), [[1,0,0],[0,1,0],[0,0,1]]), "<=", 10)
        lp.setMaximize()

        lp.setLowerBound(indices[opts[0]], None)
        lp.setUpperBound(indices[opts[0]], ubvalues[opts[1]])

        for num_times in range(2):  # make sure it's same anser second time
            lp.solve()

            self.assertAlmostEqual(lp.getObjectiveValue(), ub*3 + 10 * 3)

            v = lp.getSolution()

            self.assert_(len(v) == 6)
            self.assertAlmostEqual(v[0], ub)
            self.assertAlmostEqual(v[1], ub)
            self.assertAlmostEqual(v[2], ub)

            self.assertAlmostEqual(v[3], 10)
            self.assertAlmostEqual(v[4], 10)
            self.assertAlmostEqual(v[5], 10)

# 需要导入模块: from pylpsolve import LP [as 别名]
# 或者: from pylpsolve.LP import getIndexBlock [as 别名]
    def checkLB(self, opts, lb):

        # these are indices to bound
        indices = {}
        indices["t"] = (0,3)
        indices["N"] = "a"
        indices["l"] = [0,1,2]
        indices["a"] = ar([0,1,2],dtype=uint)
        indices["f"] = ar([0,1,2],dtype=float64)

        lbvalues = {}
        lbvalues["s"] = lb
        lbvalues["l"] = [lb, lb, lb]
        lbvalues["a"] = ar([lb, lb, lb])

        lp = LP()

        if opts[0] == "N":
            lp.getIndexBlock(indices["N"], 3)

        lp.setObjective([1,1,1,1,1,1])

        lp.setLowerBound(indices[opts[0]], lbvalues[opts[1]])

        for num_times in range(2):  # make sure it's same anser second time
            lp.solve()

            self.assertAlmostEqual(lp.getObjectiveValue(), lb*3)

            v = lp.getSolution()

            self.assert_(len(v) == 6)
            self.assertAlmostEqual(v[0], lb)
            self.assertAlmostEqual(v[1], lb)
            self.assertAlmostEqual(v[2], lb)

            self.assertAlmostEqual(v[3], 0)
            self.assertAlmostEqual(v[4], 0)
            self.assertAlmostEqual(v[5], 0)

# 需要导入模块: from pylpsolve import LP [as 别名]
# 或者: from pylpsolve.LP import getIndexBlock [as 别名]
    def checkBindSandwich(self, opts):

        idxlist = [{}, {}]

        idxlist[0]["t"] = (0,3)
        idxlist[0]["N"] = "a"
        idxlist[0]["l"] = [0,1,2]
        idxlist[0]["a"] = ar([0,1,2])
        idxlist[0]["r"] = ar([0,0,1,1,2,2])[::2]
        idxlist[0]["f"] = ar([0,1,2],dtype=float64)

        idxlist[1]["t"] = (3,6)
        idxlist[1]["n"] = "b"
        idxlist[1]["l"] = [3,4,5]
        idxlist[1]["a"] = ar([3,4,5])
        idxlist[1]["r"] = ar([3,3,4,4,5,5])[::2]
        idxlist[1]["f"] = ar([3,4,5],dtype=float64)

        lp = LP()

        if opts[0] == "N":
            self.assert_(lp.getIndexBlock(idxlist[0]["N"], 3) == (0,3) )

        # Now bind the second group

        lp.bindSandwich(idxlist[0][opts[0]], idxlist[1][opts[1]])

        if opts[2] == "u":
            lp.addConstraint( (idxlist[0][opts[0]], 1), ">=", 1)
        elif opts[2] == "l":
            lp.addConstraint( (idxlist[0][opts[0]], 1), "<=", -1)
            lp.setUnbounded(idxlist[0][opts[0]])
        else:
            assert False

        lp.setObjective( (idxlist[1][opts[1]], [1,2,3]) )
        lp.setMinimize()

        lp.solve()

        v = lp.getSolution()

        v0 = 1 if opts[2] == "u" else -1

        self.assert_(len(v) == 6, "len(v) = %d != 6" % len(v))
        self.assertAlmostEqual(v[0], v0)
        self.assertAlmostEqual(v[1], 0)
        self.assertAlmostEqual(v[2], 0)
        self.assertAlmostEqual(v[3], 1)
        self.assertAlmostEqual(v[4], 0)
        self.assertAlmostEqual(v[5], 0)

        if opts[0] in "nN" and opts[1] in "nN":

            d = lp.getSolutionDict()

            self.assert_(set(d.iterkeys()) == set(["a", "b"]))

            self.assertAlmostEqual(d["a"][0], v0)
            self.assertAlmostEqual(d["a"][1], 0)
            self.assertAlmostEqual(d["a"][2], 0)
            self.assertAlmostEqual(d["b"][0], 1)
            self.assertAlmostEqual(d["b"][1], 0)
            self.assertAlmostEqual(d["b"][2], 0)

# 需要导入模块: from pylpsolve import LP [as 别名]
# 或者: from pylpsolve.LP import getIndexBlock [as 别名]
    def checkBindEach(self, opts):

        idxlist = [{}, {}]

        idxlist[0]["t"] = (0,3)
        idxlist[0]["N"] = "a"
        idxlist[0]["l"] = [0,1,2]
        idxlist[0]["a"] = ar([0,1,2])
        idxlist[0]["r"] = ar([0,0,1,1,2,2])[::2]
        idxlist[0]["f"] = ar([0,1,2],dtype=float64)

        idxlist[1]["t"] = (3,6)
        idxlist[1]["n"] = "b"
        idxlist[1]["l"] = [3,4,5]
        idxlist[1]["a"] = ar([3,4,5])
        idxlist[1]["r"] = ar([3,3,4,4,5,5])[::2]
        idxlist[1]["f"] = ar([3,4,5],dtype=float64)

        lp = LP()

        if opts[0] == "N":
            self.assert_(lp.getIndexBlock(idxlist[0]["N"], 3) == (0,3) )

        # Now bind the second group
        if opts[2] == "g":
            self.assert_(
                lp.bindEach(idxlist[1][opts[1]], ">", idxlist[0][opts[0]])
                == [0,1,2])

        elif opts[2] == "l":
            self.assert_(
                lp.bindEach(idxlist[0][opts[0]], "<", idxlist[1][opts[1]])
                == [0,1,2])

        elif opts[2] == "e":
            self.assert_(
                lp.bindEach(idxlist[0][opts[0]], "=", idxlist[1][opts[1]])
                == [0,1,2])
        elif opts[2] == "E":
            self.assert_(
                lp.bindEach(idxlist[1][opts[1]], "=", idxlist[0][opts[0]])
                == [0,1,2])
        else:
            assert False

        # Forces some to be defined implicitly above to catch that case
        lp.addConstraint( (idxlist[0][opts[0]], 1), ">=", 1)

        lp.setObjective( (idxlist[1][opts[1]], [1,2,3]) )
        lp.setMinimize()

        lp.solve()

        v = lp.getSolution()

        self.assert_(len(v) == 6, "len(v) = %d != 6" % len(v))
        self.assertAlmostEqual(v[0], 1)
        self.assertAlmostEqual(v[1], 0)
        self.assertAlmostEqual(v[2], 0)
        self.assertAlmostEqual(v[3], 1)
        self.assertAlmostEqual(v[4], 0)
        self.assertAlmostEqual(v[5], 0)

        if opts[0] in "nN" and opts[1] in "nN":

            d = lp.getSolutionDict()

            self.assert_(set(d.iterkeys()) == set(["a", "b"]))

            self.assertAlmostEqual(d["a"][0], 1)
            self.assertAlmostEqual(d["a"][1], 0)
            self.assertAlmostEqual(d["a"][2], 0)
            self.assertAlmostEqual(d["b"][0], 1)
            self.assertAlmostEqual(d["b"][1], 0)
            self.assertAlmostEqual(d["b"][2], 0)

# 需要导入模块: from pylpsolve import LP [as 别名]
# 或者: from pylpsolve.LP import getIndexBlock [as 别名]
    def test01(self):
        lp = LP()

        self.assert_(lp.getIndexBlock(2, "a1") == (0,2))

# 需要导入模块: from pylpsolve import LP [as 别名]
# 或者: from pylpsolve.LP import getIndexBlock [as 别名]
    def test04_bad_size_05(self):
        lp = LP()

        self.assertRaises(ValueError, lambda: lp.getIndexBlock(0, 2))

# 需要导入模块: from pylpsolve import LP [as 别名]
# 或者: from pylpsolve.LP import getIndexBlock [as 别名]
    def test04_bad_size_04(self):
        lp = LP()

        self.assertRaises(ValueError, lambda: lp.getIndexBlock("a1", "a2"))

# 需要导入模块: from pylpsolve import LP [as 别名]
# 或者: from pylpsolve.LP import getIndexBlock [as 别名]
    def test03_bad_recall(self):
        lp = LP()

        self.assert_(lp.getIndexBlock(2, "a1") == (0,2))
        self.assert_(lp.getIndexBlock(4, "a2") == (2,6))
        self.assertRaises(ValueError, lambda: lp.getIndexBlock(3, "a1"))

# 需要导入模块: from pylpsolve import LP [as 别名]
# 或者: from pylpsolve.LP import getIndexBlock [as 别名]
    def test02_reverse_order_mixed(self):
        lp = LP()

        self.assert_(lp.getIndexBlock("a1", 2) == (0,2))
        self.assert_(lp.getIndexBlock(4, "a2") == (2,6))
        self.assert_(lp.getIndexBlock("a1", 2) == (0,2))

# 需要导入模块: from pylpsolve import LP [as 别名]
# 或者: from pylpsolve.LP import getIndexBlock [as 别名]
    def test02(self):
        lp = LP()

        self.assert_(lp.getIndexBlock(2, "a1") == (0,2))
        self.assert_(lp.getIndexBlock(4, "a2") == (2,6))
        self.assert_(lp.getIndexBlock("a1") == (0,2))

# 需要导入模块: from pylpsolve import LP [as 别名]
# 或者: from pylpsolve.LP import getIndexBlock [as 别名]
    def test01_r(self):
        lp = LP()

        self.assert_(lp.getIndexBlock("a1", 2) == (0,2))

# 需要导入模块: from pylpsolve import LP [as 别名]
# 或者: from pylpsolve.LP import getIndexBlock [as 别名]
    def checkBadSizingTooLarge(self, opts):
        
        lp = LP()

        def run_test(c_arg, o_arg):
            if opts[-1] == "c":
                self.assertRaises(ValueError, lambda: lp.addConstraint(c_arg, ">", 1))
            elif opts[-1] == "o":
                self.assertRaises(ValueError, lambda: lp.setObjective(o_arg))
            else:
                assert False

        indices = {}
        indices["t"] = (0,3)
        indices["N"] = "a"
        indices["l"] = [0,1,2]
        indices["a"] = ar([0,1,2])
        indices["f"] = ar([0,1,2],dtype=float64)

        weights = {}
        weights["l"] = [1,1,1,1]
        weights["a"] = ar([1,1,1,1])
        weights["f"] = ar([1,1,1,1])

        obj_func = {}
        obj_func["l"] = [1,2,3,4]
        obj_func["a"] = ar([1,2,3,4])
        obj_func["f"] = ar([1,2,3,4],dtype=float64)


        # Some ones used in the dict's case
        il = indices["l"] 
        assert len(il) == 3

        wl = weights["l"]
        assert len(wl) == 4

        ol = obj_func["l"]
        assert len(ol) == 4

        if opts[0] == "d" or opts[0] == "T":

            if opts[1] == "2":
                lp.getIndexBlock("b", 1)
                cd = [ ("a", wl[:2]), ("b", wl[2:])]
                od = [ ("a", ol[:2]), ("b", ol[2:])]
            
            elif opts[1] == "3":
                cd = [((0,2), wl[:2]), (2, wl[2:])]
                od = [((0,2), ol[:2]), (2, ol[2:])]

            elif opts[1] == "4":
                cd = [((0,2), wl[:2]), ( (2,3), wl[2:])]
                od = [((0,2), ol[:2]), ( (2,3), ol[2:])]

            elif opts[1] == "5":  # bad for out of order
                cd = [("a", wl[:2]), ( (2,3), wl[2:])]
                od = [("a", ol[:2]), ( (2,3), ol[2:])]
            
            elif opts[1] in indices.keys() and opts[2] in weights.keys():

                if "N" in opts:
                    lp.getIndexBlock(indices["N"], 3)

                cd = [(indices[opts[1]], weights[opts[2]])]
                od = [(indices[opts[1]], obj_func[opts[2]])]
            else:
                assert False

            if opts[0] == "d":
                run_test(dict(cd), dict(od))
                return
            elif opts[0] == "T":
                run_test(cd, od)
                return
            else:
                assert False
        else:
            assert len(opts) == 3
            
            # No little n option here
            if "N" in opts:
                lp.getIndexBlock(indices["N"], 3)
            
            run_test( (indices[opts[0]], weights[opts[1]]),
                      (indices[opts[0]], obj_func[opts[1]]))
            return