def test_contains(self): Q = FiniteBestSet(N=10) for x in self.ar: Q.add(x,x) for elem in self.max_set: self.assertTrue(Q.__contains__(elem)) for elem in self.min_set: self.assertFalse(Q.__contains__(elem))
def test_len(self): Q = FiniteBestSet(N=10) count = 0 self.assertEqual(Q.__len__(), 0) for x in self.ar: Q.add(x,x) count = min(count+1, 10) self.assertEqual(Q.__len__(), count)
def test_len(self): Q = FiniteBestSet(N=10) count = 0 self.assertEqual(Q.__len__(), 0) for x in self.ar: Q.add(x, x) count = min(count + 1, 10) self.assertEqual(Q.__len__(), count)
def test_contains(self): Q = FiniteBestSet(N=10) for x in self.ar: Q.add(x, x) for elem in self.max_set: self.assertTrue(Q.__contains__(elem)) for elem in self.min_set: self.assertFalse(Q.__contains__(elem))
def test_min(self): Q = FiniteBestSet(N=10, max=False) for x in self.ar: Q.add(x, x) self.assertTrue(set(Q.get_all()).issuperset(set(self.min_set))) self.assertTrue(set(Q.get_all()).issubset(set(self.min_set)))
def test_max(self): Q = FiniteBestSet(N=10) for x in self.ar: Q.add(x, x) self.assertTrue(set(Q.get_all()).issuperset(set(self.max_set))) self.assertTrue(set(Q.get_all()).issubset(set(self.max_set)))
def enumerative_search( start, next_states, score, N=-1, breakout=float("inf"), yield_immediate=False): """ start -- either a list or a single element saying what we start with. Generally this works better with a rich starting base next_states is a function mapping states to a list of potential next states score - maps states to values, higher is better (UNLIKE priority queue) breakout -- if the current score is worse than max_so_far - breakout, then don't go further this is useful for doing integration since we can ignore the very tiny. This makes the search considerably more efficient, but may not result in correctness NOTE / TODO: This has one inefficiency which is that if we find a new path to a state, we just push it on so there are two copies on the stack. The second won't be visited again since it will be put in "visited" the first time it's seen but we could remove it, and then the stack size would be more correct """ ## Main code: Q = FiniteBestSet(N=N, max=True) # the priority queue visited = set() # a set of states we've seen already enumerative_search.maxsofar = float("-inf") # ugh a workaround since nested functions can't change this otherwise # an function to score and potentially push a value def score_and_push(k): """ Score and push, returning the scored value """ if k not in visited: p = score(k) if (enumerative_search.maxsofar - breakout > p): return None# if p is really bad, don't append # Hmm this could go before or after the above breakout line -- for really big spaces, # we should do this after so we don't cache a lot of nonsense; for really slow # evaluation functions, this should go before so we don't repeat visited.add(k) if p != None: # if we return None, don't do it # otherwise push onto queue if p > enumerative_search.maxsofar: enumerative_search.maxsofar = p Q.push(k, p) return p # add the start state if not isinstance(start, list): start = list(start) for k in start: p = score_and_push(k) if yield_immediate and (p is not None): yield k,p ## Main loop: while len(Q) > 0 and not LOTlib.SIG_INTERRUPTED: # while there is something in the queue #print len(Q) #print out the current priority queue #i = 0 #for g in Q.Q: #print " >", g.priority, g.value #i += 1 #if i > 50: break #print "\n\n" x, s = Q.pop_both() # if we are yeilding from the top of the queue if not yield_immediate: yield x, s for k in next_states(x): p = score_and_push(k) # if we are yeilding as we score if yield_immediate and (p is not None): yield k,p
def test_min(self): Q = FiniteBestSet(N=10, max=False) for x in self.ar: Q.add(x,x) self.assertTrue(set(Q.get_all()).issuperset( set(self.min_set))) self.assertTrue(set(Q.get_all()).issubset( set(self.min_set)))
def test_max(self): Q = FiniteBestSet(N=10) for x in self.ar: Q.add(x,x) self.assertTrue(set(Q.get_all()).issuperset( set(self.max_set))) self.assertTrue(set(Q.get_all()).issubset( set(self.max_set)))