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)
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)
def testBasicBasis(self): # this should work as it's in the examples lp = LP() lp.addConstraint( (0, 1), "<", 3) lp.addConstraint( (1, 1), "<", 3) lp.setMaximize() lp.setObjective([1,1]) lp.solve(guess = [3,3]) self.assert_(lp.getInfo("Iterations") == 0, lp.getInfo("Iterations"))
def testBasicBasis(self): # this should work as it's in the examples lp = LP() lp.addConstraint((0, 1), "<", 3) lp.addConstraint((1, 1), "<", 3) lp.setMaximize() lp.setObjective([1, 1]) lp.solve(guess=[3, 3]) self.assert_(lp.getInfo("Iterations") == 0, lp.getInfo("Iterations"))
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)
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)
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)
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)
def demo(): print 'demo for using lpsolve...' print 'using lpsolve to solve the problem..' lp = LP() ##Specify constaints ##(1)x+y<=3 ##(2)y+z<=4 lp.addConstraint([[1, 1, 0], [0, 1, 2]], "<=", [3, 4]) # Force the first variable to be integer-valued ##lp.setInteger(0) ##all variables lp.setBinary([0, 1, 2]) #set objective lp.setObjective([1, 1, 1], mode='minimize') ##return = lpsolve('set_binary', lp, column, must_be_bin) lp.solve() ##print out the solution print lp.getSolution()
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)
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)
def lpsolve_infer(ims, prev_boxes, cur_boxes, next_boxes, fw_masks, cur_masks, bw_masks, shift_arr): picked_boxes = [] picked_masks = [] y_labels = [] ave_iou = [] frm_num = len(fw_masks) ## calculate the pairwise items based on maskIoU pairwise_arr = get_pairwise_arr(ims, prev_boxes, cur_boxes, next_boxes, fw_masks, cur_masks, bw_masks, shift_arr) tmp_masks = [] for frm_id in xrange(frm_num): tmp_masks.append(fw_masks[frm_id]) tmp_masks.append(cur_masks[frm_id]) tmp_masks.append(bw_masks[frm_id]) all_masks = np.asarray(tmp_masks) tmp_bboxes = [] for frm_id in xrange(frm_num): tmp_bboxes.append(prev_boxes[frm_id]) tmp_bboxes.append(cur_boxes[frm_id]) tmp_bboxes.append(next_boxes[frm_id]) all_boxes = np.asarray(tmp_bboxes) ##====================================================== Construct Graph begining============================================================## ##(0)set up parameters: edge_num = frm_num * 9 - 3 node_num = frm_num * 3 + 2 var_len = edge_num + node_num ##(1)set node and edge index ## 1.1 val_indexes val_indexes = np.zeros(var_len, dtype=int) for val_id in xrange(var_len): val_indexes[val_id] = val_id ##------------------------------------------------------------node indexes------------------------------------------------------------ ##1.2 node_indexes node_indexes = np.zeros(node_num, dtype=int) node_indexes[0] = 0 #source node node_indexes[-1] = var_len - 1 #sink node ##1.2.1 (indexes of(node) in val_indexes) for frm_id in xrange(frm_num): node_id1 = frm_id * 12 + 4 if frm_id == frm_num - 1: ##last frame node_id2 = node_id1 + 1 node_id3 = node_id1 + 2 else: node_id2 = node_id1 + 4 ## other frames node_id3 = node_id1 + 8 t_nodes = [node_id1, node_id2, node_id3] ##1.2.2 (indexes of (node)in node_indexes) t_id1 = (frm_id + 1) * 3 - 2 t_id3 = t_id1 + 2 node_indexes[t_id1:t_id3 + 1] = t_nodes ##--------------------------------------------------------------edge indexes-------------------------------------------------------- ##1.3 edge_indexes edge_indexes = np.asarray(list(set(val_indexes) - set(node_indexes))) ##-------------------------------------------------------------Coeficient vector----------------------------------------------------- ##(2) set cofficent vector coef_vec = np.zeros((var_len)) ##2.1 node cofficient coef_vec[node_indexes] = 1 ##set all the node(unary term) as 1 ##2.2 edge cofficient coef_vec[1:4] = 1 #the first three edges linked to the source node coef_vec[-4:-1] = 1 #the last three edges linked to the sink node ##set up pairwise term(edges) pairwise_indexes = edge_indexes[3:-3] coef_vec[pairwise_indexes] = pairwise_arr print 'pairwise_indexes:', pairwise_indexes print pairwise_indexes.shape print 'pairwise_arr:', pairwise_arr print pairwise_arr.shape ##=================================================================Equation constraints========================## ## AX=B equ_num = 2 + ( frm_num ) * 3 * 2 ## 2 for first and last node(with 3 edges) + frm_num*6 for every frame(3 nodes with each one with 2) ##(3) set A Matrix a_mat = np.zeros((equ_num, var_len)) ##3.1 a_mat[0, 1:4] = 1 ## three edges flow out from the source node x1+x2+x3=1 a_mat[ -1, -4: -1] = 1 ## three edges flow into the sink node x(-1)+x(-2)+x(-3)=1 ##3.2 ##the first three edges and the three nodes(in the frist frame) a_mat[1, 1] = a_mat[2, 2] = a_mat[3, 3] = -1 #x1=x4, x2=x8, x3=x12 a_mat[1, 4] = a_mat[2, 8] = a_mat[3, 12] = 1 ##the last three edges and the three nodes(in the last frame) a_mat[equ_num - 4, var_len - 4] = a_mat[equ_num - 3, var_len - 3] = a_mat[equ_num - 2, var_len - 2] = 1 #x(-1)=x(-4), x(-2)=x(-8), x(-3)=x(-12) a_mat[equ_num - 4, var_len - 7] = a_mat[equ_num - 3, var_len - 6] = a_mat[equ_num - 2, var_len - 5] = -1 ##3.3 ##outflow constraints(1 node to 3 edges) row_idx = 4 for frm_id in xrange(frm_num - 1): t_base = frm_id * 3 + 1 for idx in xrange(3): t_id = [t_base + idx] src_node_idx = node_indexes[t_id] brh_edge_idxes = val_indexes[int(src_node_idx + 1):int(src_node_idx + 4)] a_mat[row_idx, src_node_idx] = -1 a_mat[row_idx, brh_edge_idxes] = 1 row_idx = row_idx + 1 ##3.3 ##inflow constraints(3 edges to 1 node) for frm_id in xrange(frm_num - 1): t_edge_base = frm_id * 9 + 3 frm_id1 = frm_id + 1 t_node_base = frm_id1 * 3 + 1 ##node base for idx in xrange(3): t_node_id = [t_node_base + idx] dest_node_idx = node_indexes[t_node_id] t_edge_id = [t_edge_base + idx] src_edge_id = edge_indexes[t_edge_id][0] src_edge_idxes = np.asarray( [src_edge_id, src_edge_id + 4, src_edge_id + 8]) a_mat[row_idx, dest_node_idx] = -1 a_mat[row_idx, src_edge_idxes] = 1 row_idx = row_idx + 1 ##4. set B Vector b_vec = np.zeros(equ_num) b_vec[0] = b_vec[-1] = 1 ##===============================================================================Solvers========================================================= lp = LP() lp.addConstraint(a_mat, "=", b_vec) # ##all variables lp.setBinary(val_indexes) # #set objective lp.setObjective(coef_vec, mode='maximize') lp.solve() val_y = lp.getSolution() ##---------------------------------------------------------------------------------------------------------------------------------------- ## map choosen nodes chosen_nodes = val_y[node_indexes] y = np.where(chosen_nodes[1:-1] > 0)[0] y_labels = np.asarray(y) picked_masks = all_masks[y_labels] picked_boxes = all_boxes[y_labels] ## calculate the edge iou. chosen_edges = val_y[edge_indexes] e = np.where(chosen_edges[3:-3] > 0)[0] e_labels = np.asarray(e) ave_iou = np.sum(pairwise_arr[e_labels]) / (frm_num - 1) print 'average iou:', ave_iou print 'y_label:', y_labels return picked_boxes, picked_masks, y_labels, ave_iou
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)
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)