def is_conservative(h,testing_set): """Check if a hypothesis (funciton node) is conservative or not.""" f = evaluate_expression(h, ['context']) for x in testing_set: a,b,s = x if f(a,b,s) != f(a, b.intersection(a), s.intersection(a) ): # HMM: is this right? We intersect s with a? return False return True
def is_conservative(h, testing_set): """Check if a hypothesis (funciton node) is conservative or not.""" f = evaluate_expression(h, ['context']) for x in testing_set: a, b, s = x if f(a, b, s) != f(a, b.intersection(a), s.intersection( a)): # HMM: is this right? We intersect s with a? return False return True
def value2function(self, value): """ How we convert a value into a function. Default is LOTlib.Miscellaneous.evaluate_expression """ # Risky here to catch all exceptions, but we'll do it and warn on failure try: return evaluate_expression(value, args=self.args) except Exception as e: print "# Warning: failed to execute evaluate_expression on " + str(value) print "# ", e return lambdaNone
def compile_function(self): """Called in set_value to compile into a function.""" if self.value.count_nodes() > self.maxnodes: return lambda *args: raise_exception(TooBigException) else: try: return evaluate_expression(str(self)) except Exception as e: print "# Warning: failed to execute evaluate_expression on " + str(self) print "# ", e return lambda *args: raise_exception(EvaluationException)
def value2function(self, value): """ How we convert a value into a function. Default is LOTlib.Miscellaneous.evaluate_expression """ # Risky here to catch all exceptions, but we'll do it and warn on failure try: return evaluate_expression(value, args=self.args) except Exception as e: print "# Warning: failed to execute evaluate_expression on " + str( value) print "# ", e return lambdaNone
def compile_function(self): """ Overwrite this from FunctionHypothesis. Here, we add args for the constants so we can use them """ return evaluate_expression(str(self))
#grammar.add_rule('FUNCTION', 'lambda', ['EXPR'], 1.0, bv_type='BOOL', bv_args=['EXPR']) # Etc. # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Conditional: # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # if_ gets printed specially (see LOTlib.FunctionNode.__str__). Here COND is a name that is made up # here for conditional expressions grammar.add_rule('EXPR', 'if_', ['COND', 'EXPR', 'EXPR'], 1.0) grammar.add_rule('COND', 'gt_', ['EXPR', 'EXPR'], 1.0) grammar.add_rule('COND', 'eq_', ['EXPR', 'EXPR'], 1.0) # Note that because if_ prints specially, it is correctly handled (via short circuit evaluation) # so that we don't eval both branches unnecessarily for _ in xrange(1000): t = grammar.generate( ) # Default is to generate from 'START'; else use 'START=t' to generate from type t # Now x is a FunctionNode # We can compile it via LOTlib.Miscellaneous.evaluate_expression # This says that t is a *function* with arguments 'x' (allowed via the grammar above) # The alternative way to do this would be to put a lambda at the top of each tree f = evaluate_expression(t, args=['x']) print t # will call x.__str__ and display as a pythonesque string print map(f, range(0, 10))
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # if_ gets printed specially (see LOTlib.FunctionNode.__str__). Here COND is a name that is made up # here for conditional expressions grammar.add_rule('EXPR', 'if_', ['COND', 'EXPR', 'EXPR'], 1.0) grammar.add_rule('COND', 'gt_', ['EXPR', 'EXPR'], 1.0) grammar.add_rule('COND', 'eq_', ['EXPR', 'EXPR'], 1.0) # Note that because if_ prints specially in FunctionNode, it is correctly handled (via short circuit evaluation) # so that we don't eval both branches unnecessarily if __name__ == "__main__": for _ in xrange(1000): t = grammar.generate( ) # Default is to generate from 'START'; else use 'START=t' to generate from type t # We can make this into a function by adding a lambda and a variable name, corresponding to # the argument "x" that we built into the grammar. This step is defaultly done by a a LOTHypothesis (see below) f = evaluate_expression('lambda x:%s' % t) print t # will call x.__str__ and display as a pythonesque string print map(f, range(0, 10)) # Alternatively, we can just make a LOTHypothesis, which is typically the only place in LOTlib we use trees from LOTlib.Hypotheses.LOTHypothesis import LOTHypothesis h = LOTHypothesis(grammar, value=t, args=['x']) print map(h, range(0, 10))
# Etc. # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Conditional: # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # if_ gets printed specially (see LOTlib.FunctionNode.__str__). Here COND is a name that is made up # here for conditional expressions grammar.add_rule('EXPR', 'if_', ['COND', 'EXPR', 'EXPR'], 1.0) grammar.add_rule('COND', 'gt_', ['EXPR', 'EXPR'], 1.0) grammar.add_rule('COND', 'eq_', ['EXPR', 'EXPR'], 1.0) # Note that because if_ prints specially, it is correctly handled (via short circuit evaluation) # so that we don't eval both branches unnecessarily for _ in xrange(1000): t = grammar.generate() # Default is to generate from 'START'; else use 'START=t' to generate from type t # Now x is a FunctionNode # We can compile it via LOTlib.Miscellaneous.evaluate_expression # This says that t is a *function* with arguments 'x' (allowed via the grammar above) # The alternative way to do this would be to put a lambda at the top of each tree f = evaluate_expression(t, args=['x']) print t # will call x.__str__ and display as a pythonesque string print map(f, range(0,10))
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # if_ gets printed specially (see LOTlib.FunctionNode.__str__). Here COND is a name that is made up # here for conditional expressions grammar.add_rule("EXPR", "if_", ["COND", "EXPR", "EXPR"], 1.0) grammar.add_rule("COND", "gt_", ["EXPR", "EXPR"], 1.0) grammar.add_rule("COND", "eq_", ["EXPR", "EXPR"], 1.0) # Note that because if_ prints specially in FunctionNode, it is correctly handled (via short circuit evaluation) # so that we don't eval both branches unnecessarily if __name__ == "__main__": for _ in xrange(1000): t = grammar.generate() # Default is to generate from 'START'; else use 'START=t' to generate from type t # We can make this into a function by adding a lambda and a variable name, corresponding to # the argument "x" that we built into the grammar. This step is defaultly done by a a LOTHypothesis (see below) f = evaluate_expression("lambda x:%s" % t) print t # will call x.__str__ and display as a pythonesque string print map(f, range(0, 10)) # Alternatively, we can just make a LOTHypothesis, which is typically the only place in LOTlib we use trees from LOTlib.Hypotheses.LOTHypothesis import LOTHypothesis h = LOTHypothesis(grammar, value=t, args=["x"]) print map(h, range(0, 10))