def primMST(G):
    """ Return MST of the given undirected graph"""
    vis = set()
    tot_weight = 0
    pq = PQDict()            
    Gprime = nx.Graph()
    
    ''' Add all nodes to PQDict with infinite distance'''
    for node in G.nodes():
        pq.additem(node, float("inf"))
    
    curr = pq.pop()    #Select initial node
    vis.add(curr)
    while len(pq) > 0:
        for s,nod, wt in G.edges(curr, data=True):
            if nod not in vis and wt['weight'] < pq[nod]: pq.updateitem(nod, wt['weight']) 
        
        if len(pq)>0:            
            top = pq.top()
            source,destination, dist = [data for data in sorted(G.edges(top, data=True), key=lambda (source,target,data): data['weight']) if data[1] in vis][0]
            Gprime.add_edge(source, destination, weight = dist['weight'])
            vis.add(top)
            tot_weight += pq[top]
            curr = pq.pop()
            
    return Gprime, tot_weight
def greedy_approx(G):
    """ Return MST of the given undirected graph"""
    vis = set()
    tot_weight = 0
    pq = PQDict()
    path = []
    '''Initialize Priority Queue which will help us find Farthest node after distance is calcualted from visited node'''
    for node in G.nodes():
        pq.additem(node, float("-inf"))

    curr = pq.pop()
    vis.add(curr)
    path.append(curr)
    while len(pq) > 0:
        for s, nod, wt in G.edges(curr, data=True):
            '''Distance calculation'''
            if nod not in vis and -wt['weight'] > pq[nod]:
                pq.updateitem(nod, -wt['weight'])

        if len(pq) > 0:
            ''' Selection Step'''
            top = pq.top()
            vis.add(top)
            curr = pq.pop()
            ''' Insertion Step'''
            loc, cost = minCost(G, path, top)
            '''Insert into the location found by minCost()'''
            path.insert(loc, top)
            tot_weight += cost

    return path, tot_weight
Beispiel #3
0
def primMST(G):
    """ Return MST of the given undirected graph"""
    vis = set()
    tot_weight = 0
    pq = PQDict()
    Gprime = nx.Graph()
    ''' Add all nodes to PQDict with infinite distance'''
    for node in G.nodes():
        pq.additem(node, float("inf"))

    curr = pq.pop()  #Select initial node
    vis.add(curr)
    while len(pq) > 0:
        for s, nod, wt in G.edges(curr, data=True):
            if nod not in vis and wt['weight'] < pq[nod]:
                pq.updateitem(nod, wt['weight'])

        if len(pq) > 0:
            top = pq.top()
            source, destination, dist = [
                data for data in sorted(G.edges(top, data=True),
                                        key=lambda
                                        (source, target, data): data['weight'])
                if data[1] in vis
            ][0]
            Gprime.add_edge(source, destination, weight=dist['weight'])
            vis.add(top)
            tot_weight += pq[top]
            curr = pq.pop()

    return Gprime, tot_weight
def greedy_approx(G):
    """ Return MST of the given undirected graph"""
    vis = set()
    tot_weight = 0
    pq = PQDict()            
    path = []
    
    '''Initialize Priority Queue which will help us find Farthest node after distance is calcualted from visited node''' 
    for node in G.nodes():
        pq.additem(node, float("-inf"))
    
    curr = pq.pop()
    vis.add(curr)
    path.append(curr)
    while len(pq) > 0:
        for s,nod, wt in G.edges(curr, data=True):
            '''Distance calculation'''
            if nod not in vis and -wt['weight'] > pq[nod]: pq.updateitem(nod, -wt['weight']) 
        
        if len(pq)>0:
            ''' Selection Step'''
            top = pq.top()
            vis.add(top)
            curr = pq.pop()
            ''' Insertion Step'''
            loc,cost = minCost(G,path,top)
            '''Insert into the location found by minCost()'''
            path.insert(loc, top)
            tot_weight += cost
            
    return path,tot_weight
 def test_updateitem(self):
     pq = PQDict(self.items)
     dkey, pkey = random.choice(self.items)
     # assign same value
     pq.updateitem(dkey, pkey)
     self.assertEqual(pq[dkey], pkey)
     # assign new value
     pq.updateitem(dkey, pkey + 1.0)
     self.assertEqual(pq[dkey], pkey + 1.0)
     # can only update existing dkeys
     self.assertRaises(KeyError, pq.updateitem, 'does_not_exist', 99.0)  
Beispiel #6
0
    def plan(self, start_state, goal_state):
        #PQ = pqdict()
        V = {}

        self.goal_state = goal_state
        h0 = self.heuristic(start_state, goal_state)
        n0 = node(start_state, None, None, 0, h0)

        key0 = np.around(n0.state, decimals=1).tostring()
        PQ = PQDict(key0=n0)

        i = 0
        while PQ and i < 100000:
            current = PQ.popitem()[1]
            #print '\n'
            #print current.state[2]
            if (self.state_is_equal(current.path, goal_state)):
                path = self.reconstruct_path(current)
                return (path, current.f)

            V[np.around(current.state,
                        decimals=1).tostring()] = copy.deepcopy(current)

            #get children
            children = self.getChildren(
                current)  #do set parent, should return an array of nodes

            for child in children:
                i += 1
                if i % 100 == 0:
                    print 'A* iteration ' + str(i)

                child_key = np.around(child.state, decimals=1).tostring()
                if child_key in V:
                    if child.f >= V[child_key].f:
                        continue

                if (child_key in PQ):
                    existing_child = PQ[child_key]
                    if (child.g >= existing_child.g):
                        continue
                    else:
                        PQ.updateitem(child_key, child)
                else:
                    #print child.state, current.state
                    #pdb.set_trace()
                    #if(child.state[2] < 0):
                    #    pdb.set_trace()
                    PQ.additem(child_key, child)

        print 'A* Failed'
        return (None, None)
Beispiel #7
0
    def plan(self, start_state, goal_state):
        #PQ = pqdict()
        V = {}

        self.goal_state = goal_state
        h0 = self.heuristic(start_state, goal_state)
        n0 = node(start_state, None, None, 0, h0)

        key0 = np.around(n0.state, decimals = 1).tostring()
        PQ = PQDict(key0=n0)

        i = 0 
        while PQ and i < 100000:
            current = PQ.popitem()[1]
            #print '\n'
            #print current.state[2]
            if(self.state_is_equal(current.path, goal_state)):
                path = self.reconstruct_path(current)
                return (path, current.f)

            V[np.around(current.state, decimals = 1).tostring()] = copy.deepcopy(current)

            #get children
            children = self.getChildren(current)#do set parent, should return an array of nodes
            
            for child in children:
                i += 1
                if i%100 == 0:
                    print 'A* iteration '+str(i)
                
                child_key = np.around(child.state, decimals = 1).tostring()
                if child_key in V:
                    if child.f >= V[child_key].f:
                        continue
                
                if (child_key in PQ):
                    existing_child = PQ[child_key]
                    if(child.g >= existing_child.g):
                        continue
                    else:
                        PQ.updateitem(child_key, child)
                else:
                    #print child.state, current.state
                    #pdb.set_trace()
                    #if(child.state[2] < 0):
                    #    pdb.set_trace()
                    PQ.additem(child_key,child)
        
        print 'A* Failed'
        return (None, None)
def primWeight(G):
    """ Return MST of the given undirected graph"""
    vis = set()
    tot_weight = 0
    pq = PQDict()            
    
    for node in G.nodes():
        pq.additem(node, float("inf"))
    
    curr = pq.pop()
    vis.add(curr)
    while len(pq) > 0:
        for s,nod, wt in G.edges(curr, data=True):
            if nod not in vis and wt['weight'] < pq[nod]: pq.updateitem(nod, wt['weight']) 
        
        if len(pq)>0:
            top = pq.top()
            vis.add(top)
            tot_weight += pq[top]
            curr = pq.pop()
    return tot_weight
Beispiel #9
0
def primWeight(G):
    """ Return MST of the given undirected graph"""
    vis = set()
    tot_weight = 0
    pq = PQDict()

    for node in G.nodes():
        pq.additem(node, float("inf"))

    curr = pq.pop()
    vis.add(curr)
    while len(pq) > 0:
        for s, nod, wt in G.edges(curr, data=True):
            if nod not in vis and wt['weight'] < pq[nod]:
                pq.updateitem(nod, wt['weight'])

        if len(pq) > 0:
            top = pq.top()
            vis.add(top)
            tot_weight += pq[top]
            curr = pq.pop()
    return tot_weight
def gillespie_nrm(tspan, initial_amounts, reactions, dep_graph):
    """
    Implementation of the "Next-Reaction Method" variant of the Gillespie 
    stochastic simulation algorithm, described by Gibson and Bruck. 

    The main enhancements are:
        - Use of dependency graph between reactions to prevent needless 
          rescheduling of reaction channels that are unaffected by an event.
        - Use of an indexed priority queue (pqdict) as a scheduler to achieve
          log(N) rescheduling.

    The paper describes an additional modification to cut down on the amount of 
    random number generation which was not implemented here for simplicity.

    """

    # initialize state
    t = tspan[0]
    x = initial_amounts
    T = [t]
    X = [x]
    a = {}
    
    # initialize scheduler
    scheduler = PQDict()
    for rxn in reactions:
        a[rxn] = rxn.propensity(x)
        tau = -log(rand())/a[rxn]   
        scheduler[rxn] = t + tau

    # first event
    rnext, tmin = scheduler.topitem()
    t = tmin
    x += rnext.stoich
    T.append( t )
    X.append( x.copy() )

    # main loop
    while t < tspan[1]:
        # reschedule
        a[rnext] = rnext.propensity(x)
        tau = -log(rand())/a[rnext]
        scheduler.updateitem(rnext, t + tau)        
        for rxn in dep_graph[rnext]:
            a_old = a[rxn]
            a[rxn] = rxn.propensity(x)
            if isfinite(scheduler[rxn]):
                tau = (a_old/a[rxn])*(scheduler[rxn] - t)
            else:
                tau = -log(rand())/a[rxn]
            scheduler.updateitem(rxn, t + tau)

        rnext, tmin = scheduler.topitem()

        # fire!
        t = tmin
        x += rnext.stoich
        T.append( t )
        X.append( x.copy() )

    return array(T), array(X)
Beispiel #11
0
    if test:
        print "next_node is %d" % next_node[0]
    cost_sum = cost_sum + next_node[1]
    if test:
        print "current cost_sum is %d" % cost_sum
    mst.append(next_node[0])
    if test:
        print "current mst is", mst
    for edge in edges:
        node1 = edge[0]
        node2 = edge[1]
        cost = edge[2]
        if (node1 == next_node[0]) and (node2 not in mst):
            if costs[node2] > cost:
                if test:
                    print "node %d needs update, old cost is %d, new cost is %d" % (node2, costs[node2], cost)
                heap.updateitem(node2, cost)
                costs[node2] = cost
        elif (node2 == next_node[0]) and (node1 not in mst):
            if costs[node1] > cost:
                if test:
                    print "node %d needs update, old cost is %d, new cost is %d" % (node1, costs[node1], cost)
                heap.updateitem(node1, cost)
                costs[node1] = cost

if test:
    print "the mst is", mst
    print "mst size is %d" % len(mst)
print "the total cost is %d" %cost_sum
f.close()