示例#1
0
    def test_binary_operators(self):
        u = [g0, g1, g12, g123, g1234, g134, g14, g4]
        v = [g12, g14, g23, g34]

        gs = GraphSet(u) | GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(
            gs, GraphSet([g0, g1, g12, g123, g1234, g134, g14, g23, g34, g4]))
        gs = GraphSet(u).union(GraphSet(u), GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(
            gs, GraphSet([g0, g1, g12, g123, g1234, g134, g14, g23, g34, g4]))

        gs = GraphSet(u)
        gs |= GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(
            gs, GraphSet([g0, g1, g12, g123, g1234, g134, g14, g23, g34, g4]))
        gs = GraphSet(u)
        gs.update(GraphSet(u), GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(
            gs, GraphSet([g0, g1, g12, g123, g1234, g134, g14, g23, g34, g4]))

        gs = GraphSet(u) & GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g12, g14]))
        gs = GraphSet(u).intersection(GraphSet(u), GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g12, g14]))

        gs = GraphSet(u)
        gs &= GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g12, g14]))
        gs = GraphSet(u)
        gs.intersection_update(GraphSet(u), GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g12, g14]))

        gs = GraphSet(u) - GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g4]))
        gs = GraphSet(u).difference(GraphSet(), GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g4]))

        gs = GraphSet(u)
        gs -= GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g4]))
        gs = GraphSet(u)
        gs.difference_update(GraphSet(), GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g4]))

        gs = GraphSet(u) ^ GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g23, g34, g4]))
        gs = GraphSet(u).symmetric_difference(GraphSet(), GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g23, g34, g4]))

        gs = GraphSet(u)
        gs ^= GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g23, g34, g4]))
        gs = GraphSet(u)
        gs.symmetric_difference_update(GraphSet(), GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g23, g34, g4]))

        v = [g12]
        gs = GraphSet(u) / GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g3, g34]))
        gs = GraphSet(u).quotient(GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g3, g34]))

        gs = GraphSet(u)
        gs /= GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g3, g34]))
        gs = GraphSet(u)
        gs.quotient_update(GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g3, g34]))

        gs = GraphSet(u) % GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g134, g14, g4]))
        gs = GraphSet(u).remainder(GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g134, g14, g4]))

        gs = GraphSet(u)
        gs %= GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g134, g14, g4]))
        gs = GraphSet(u)
        gs.remainder_update(GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g134, g14, g4]))

        gs = GraphSet(u).complement()
        self.assertEqual(gs, GraphSet([g0, g123, g1234, g2, g23, g234, g34, g4]))

        v = [g12, g14, g23, g34]
        gs = GraphSet(u).join(GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(
            gs, GraphSet([g12, g123, g124, g1234, g134, g14, g23, g234, g34]))

        gs = GraphSet(u).meet(GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g12, g14, g2, g23, g3, g34, g4]))

        v = [g12, g14, g23, g34]
        gs = GraphSet(u).subgraphs(GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g12, g14, g4]))

        gs = GraphSet(u).supergraphs(GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g12, g123, g1234, g134, g14]))

        gs = GraphSet(u).non_subgraphs(GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g123, g1234, g134]))

        gs = GraphSet(u).non_supergraphs(GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g4]))

        gs1 = GraphSet({}) - GraphSet([g1, g34])

        gs2 = gs1.including(GraphSet([g1, g2]))
        self.assertTrue(isinstance(gs2, GraphSet))
        self.assertEqual(len(gs2), 11)

        gs2 = gs1.including(g1)
        self.assertTrue(isinstance(gs2, GraphSet))
        self.assertEqual(len(gs2), 7)

        gs2 = gs1.including((2,1))
        self.assertTrue(isinstance(gs2, GraphSet))
        self.assertEqual(len(gs2), 7)

        gs2 = gs1.including(1)
        self.assertTrue(isinstance(gs2, GraphSet))
        self.assertEqual(len(gs2), 11)

        self.assertRaises(KeyError, gs1.including, (1, 4))
        self.assertRaises(KeyError, gs1.including, 5)

        gs2 = gs1.excluding(GraphSet([g1, g2]))
        self.assertTrue(isinstance(gs2, GraphSet))
        self.assertEqual(len(gs2), 3)

        gs2 = gs1.excluding(g1)
        self.assertTrue(isinstance(gs2, GraphSet))
        self.assertEqual(len(gs2), 7)

        gs2 = gs1.excluding(e2)
        self.assertTrue(isinstance(gs2, GraphSet))
        self.assertEqual(len(gs2), 6)

        gs2 = gs1.excluding(1)
        self.assertTrue(isinstance(gs2, GraphSet))
        self.assertEqual(len(gs2), 3)

        self.assertRaises(KeyError, gs1.excluding, (1, 4))
        self.assertRaises(KeyError, gs1.excluding, 5)

        v = [g12, g14, g23, g34]
        gs = GraphSet(u).included(GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g12, g14, g4]))

        gs = GraphSet(u).included(g12)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g12]))
示例#2
0
f = calc_f(nk)
m_np = calc_mnp(nk, f)

print("f = ", f, " m = ", m_np)
# file = open('output.txt','a')
# file.write("p ={0}, eps = {1}, f = {2}, m = {3} \n".format(p, eps, f, m_np))
# file.close()

tl = []
R_min_global = np.inf
for itr_cand in range(1):
    cand_list = GraphSet()

    #故障しないものはcand_listへ
    for i in range(0, 1):
        cand_list.update(gc.len(E - i))
    #print(cand_list.len())

    # #f本故障はm_npの数だけ抽出(ひとまずランダムに)
    # cand_select = gc.len(E-f)
    # #print(cand_select.len())
    # for cnt in range(0,m_np):
    #     rand_graph = next(cand_select.rand_iter())
    #     cand_list.add(rand_graph)
    #     cand_select.remove(rand_graph)

    print("total {0} patterns to consider".format(cand_list.len()))
    for i in cand_list:
        print(i)

    #-------------Optimization------------------
示例#3
0
#-------------Optimization-mf------------------
tl_mf = []
R_min_mf = np.inf
w_opt_mf = copy.deepcopy(weights)

tl_so = []
R_min_so = np.inf
w_opt_so = copy.deepcopy(weights)

#-----Set F_mf in PSO-M  and non-failure case in SO-----
cand_mf = GraphSet()
cand_so = GraphSet()

#Setting for F_mf
for i in range(0, f):
    cand_mf.update(gc.len(E - i))
cand_select = gc.len(E - f)
for cnt in range(0, m_np):
    rand_graph = next(cand_select.rand_iter())
    cand_mf.add(rand_graph)
    cand_select.remove(rand_graph)

#Setting non-failure set
cand_so = GraphSet()
cand_so.update(gc.len(E))
# for i in cand_so:
#     print(i)

# print("total {0} patterns to consider".format(cand_mf.len()))
# print("total {0} patterns to consider".format(cand_so.len()))
# for i in cand_mf:
示例#4
0
    def test_binary_operators(self):
        u = [g0, g1, g12, g123, g1234, g134, g14, g4]
        v = [g12, g14, g23, g34]

        gs = GraphSet(u) | GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(
            gs, GraphSet([g0, g1, g12, g123, g1234, g134, g14, g23, g34, g4]))
        gs = GraphSet(u).union(GraphSet(u), GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(
            gs, GraphSet([g0, g1, g12, g123, g1234, g134, g14, g23, g34, g4]))

        gs = GraphSet(u)
        gs |= GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(
            gs, GraphSet([g0, g1, g12, g123, g1234, g134, g14, g23, g34, g4]))
        gs = GraphSet(u)
        gs.update(GraphSet(u), GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(
            gs, GraphSet([g0, g1, g12, g123, g1234, g134, g14, g23, g34, g4]))

        gs = GraphSet(u) & GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g12, g14]))
        gs = GraphSet(u).intersection(GraphSet(u), GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g12, g14]))

        gs = GraphSet(u)
        gs &= GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g12, g14]))
        gs = GraphSet(u)
        gs.intersection_update(GraphSet(u), GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g12, g14]))

        gs = GraphSet(u) - GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g4]))
        gs = GraphSet(u).difference(GraphSet(), GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g4]))

        gs = GraphSet(u)
        gs -= GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g4]))
        gs = GraphSet(u)
        gs.difference_update(GraphSet(), GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g123, g1234, g134, g4]))

        gs = GraphSet(u) ^ GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs,
                         GraphSet([g0, g1, g123, g1234, g134, g23, g34, g4]))
        gs = GraphSet(u).symmetric_difference(GraphSet(), GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs,
                         GraphSet([g0, g1, g123, g1234, g134, g23, g34, g4]))

        gs = GraphSet(u)
        gs ^= GraphSet(v)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs,
                         GraphSet([g0, g1, g123, g1234, g134, g23, g34, g4]))
        gs = GraphSet(u)
        gs.symmetric_difference_update(GraphSet(), GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs,
                         GraphSet([g0, g1, g123, g1234, g134, g23, g34, g4]))

        #        v = [g12]
        #        gs = GraphSet(u) / GraphSet(v)
        #        self.assertTrue(isinstance(gs, GraphSet))
        #        self.assertEqual(gs, GraphSet([g0, g3, g34]))
        #        gs = GraphSet(u).quotient(GraphSet(v))
        #        self.assertTrue(isinstance(gs, GraphSet))
        #        self.assertEqual(gs, GraphSet([g0, g3, g34]))

        #        gs = GraphSet(u)
        #        gs /= GraphSet(v)
        #        self.assertTrue(isinstance(gs, GraphSet))
        #        self.assertEqual(gs, GraphSet([g0, g3, g34]))
        #        gs = GraphSet(u)
        #        gs.quotient_update(GraphSet(v))
        #        self.assertTrue(isinstance(gs, GraphSet))
        #        self.assertEqual(gs, GraphSet([g0, g3, g34]))

        #        gs = GraphSet(u) % GraphSet(v)
        #        self.assertTrue(isinstance(gs, GraphSet))
        #        self.assertEqual(gs, GraphSet([g0, g1, g134, g14, g4]))
        #        gs = GraphSet(u).remainder(GraphSet(v))
        #        self.assertTrue(isinstance(gs, GraphSet))
        #        self.assertEqual(gs, GraphSet([g0, g1, g134, g14, g4]))

        #        gs = GraphSet(u)
        #        gs %= GraphSet(v)
        #        self.assertTrue(isinstance(gs, GraphSet))
        #        self.assertEqual(gs, GraphSet([g0, g1, g134, g14, g4]))
        #        gs = GraphSet(u)
        #        gs.remainder_update(GraphSet(v))
        #        self.assertTrue(isinstance(gs, GraphSet))
        #        self.assertEqual(gs, GraphSet([g0, g1, g134, g14, g4]))

        gs = GraphSet(u).complement()
        self.assertEqual(gs,
                         GraphSet([g0, g123, g1234, g2, g23, g234, g34, g4]))

        #        v = [g12, g14, g23, g34]
        #        gs = GraphSet(u).join(GraphSet(v))
        #        self.assertTrue(isinstance(gs, GraphSet))
        #        self.assertEqual(
        #            gs, GraphSet([g12, g123, g124, g1234, g134, g14, g23, g234, g34]))

        #        gs = GraphSet(u).meet(GraphSet(v))
        #        self.assertTrue(isinstance(gs, GraphSet))
        #        self.assertEqual(gs, GraphSet([g0, g1, g12, g14, g2, g23, g3, g34, g4]))

        #        v = [g12, g14, g23, g34]
        #        gs = GraphSet(u).subgraphs(GraphSet(v))
        #        self.assertTrue(isinstance(gs, GraphSet))
        #        self.assertEqual(gs, GraphSet([g0, g1, g12, g14, g4]))

        #        gs = GraphSet(u).supergraphs(GraphSet(v))
        #        self.assertTrue(isinstance(gs, GraphSet))
        #        self.assertEqual(gs, GraphSet([g12, g123, g1234, g134, g14]))

        #        gs = GraphSet(u).non_subgraphs(GraphSet(v))
        #        self.assertTrue(isinstance(gs, GraphSet))
        #        self.assertEqual(gs, GraphSet([g123, g1234, g134]))

        #        gs = GraphSet(u).non_supergraphs(GraphSet(v))
        #        self.assertTrue(isinstance(gs, GraphSet))
        #        self.assertEqual(gs, GraphSet([g0, g1, g4]))

        gs1 = GraphSet({}) - GraphSet([g1, g34])

        gs2 = gs1.including(GraphSet([g1, g2]))
        self.assertTrue(isinstance(gs2, GraphSet))
        self.assertEqual(len(gs2), 11)

        gs2 = gs1.including(g1)
        self.assertTrue(isinstance(gs2, GraphSet))
        self.assertEqual(len(gs2), 7)

        gs2 = gs1.including((2, 1))
        self.assertTrue(isinstance(gs2, GraphSet))
        self.assertEqual(len(gs2), 7)

        gs2 = gs1.including(1)
        self.assertTrue(isinstance(gs2, GraphSet))
        self.assertEqual(len(gs2), 11)

        self.assertRaises(KeyError, gs1.including, (1, 4))
        self.assertRaises(KeyError, gs1.including, 5)

        gs2 = gs1.excluding(GraphSet([g1, g2]))
        self.assertTrue(isinstance(gs2, GraphSet))
        self.assertEqual(len(gs2), 3)

        gs2 = gs1.excluding(g1)
        self.assertTrue(isinstance(gs2, GraphSet))
        self.assertEqual(len(gs2), 7)

        gs2 = gs1.excluding(e2)
        self.assertTrue(isinstance(gs2, GraphSet))
        self.assertEqual(len(gs2), 6)

        gs2 = gs1.excluding(1)
        self.assertTrue(isinstance(gs2, GraphSet))
        self.assertEqual(len(gs2), 3)

        self.assertRaises(KeyError, gs1.excluding, (1, 4))
        self.assertRaises(KeyError, gs1.excluding, 5)

        v = [g12, g14, g23, g34]
        gs = GraphSet(u).included(GraphSet(v))
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g12, g14, g4]))

        gs = GraphSet(u).included(g12)
        self.assertTrue(isinstance(gs, GraphSet))
        self.assertEqual(gs, GraphSet([g0, g1, g12]))
示例#5
0
for i in range(10):
    s = np.random.randint(0,N-1)
    d = np.random.randint(0,N-1)
    while (s == d):
        d = np.random.randint(0,N-1)
    tr.append((s,d,np.random.randint(0, 100*U_d)))
# print('Traffic demands')
# print(tr)
# print('\n')

#----------Setting failure patterns--------
cand_list = GraphSet()

#1本以下の故障本数を持つものはcand_listへ
for i in range(0,2):
    cand_list.update(gc.len(E-i))
#print(cand_list.len())


print("total {0} patterns to consider".format(cand_list.len()))
# for i in cand_list:
#      print(i)

#-------------Optimization------------------

tl = []
R_min = np.inf
MAX_loop = 100
C_cnt = 0
C_max = 10
weights_tmp = copy.deepcopy(weights)