def compile_and_load(code): r""" INPUT: - ``code`` -- string containing code that could be in a .pyx file that is attached or put in a %cython block in the notebook. OUTPUT: a module, which results from compiling the given code and importing it EXAMPLES:: sage: module = sage.misc.cython.compile_and_load("def f(int n):\n return n*n") sage: module.f(10) 100 """ file = tmp_filename(ext=".pyx") open(file,'w').write(code) return cython_import(file, create_local_c_file=False)
def cython_lambda(vars, expr, verbose=False, compile_message=False, use_cache=False): """ Create a compiled function which evaluates ``expr`` assuming machine values for ``vars``. INPUT: - ``vars`` - list of pairs (variable name, c-data type), where the variable names and data types are strings, OR a string such as ``'double x, int y, int z'`` - ``expr`` - an expression involving the vars and constants; you can access objects defined in the current module scope ``globals()`` using ``sage.object_name``. .. warning:: Accessing ``globals()`` doesn't actually work, see :trac:`12446`. EXAMPLES: We create a Lambda function in pure Python (using the r to make sure the 3.2 is viewed as a Python float):: sage: f = lambda x,y: x*x + y*y + x + y + 17r*x + 3.2r We make the same Lambda function, but in a compiled form. :: sage: g = cython_lambda('double x, double y', 'x*x + y*y + x + y + 17*x + 3.2') sage: g(2,3) 55.2 sage: g(0,0) 3.2 In order to access Sage globals, prefix them with ``sage.``:: sage: f = cython_lambda('double x', 'sage.sin(x) + sage.a') sage: f(0) Traceback (most recent call last): ... NameError: global 'a' is not defined sage: a = 25 sage: f(10) 24.45597888911063 sage: a = 50 sage: f(10) 49.45597888911063 """ if isinstance(vars, str): v = vars else: v = ', '.join(['%s %s'%(typ,var) for typ, var in vars]) s = """ cdef class _s: cdef globals def __init__(self): from sage.repl.user_globals import get_globals self.globals = get_globals() def __getattr__(self, name): try: return self.globals[name] except KeyError: raise NameError("global {!r} is not defined".format(name)) sage = _s() def f(%s): return %s """%(v, expr) if verbose: print(s) tmpfile = tmp_filename(ext=".spyx") open(tmpfile,'w').write(s) d = {} cython_import_all(tmpfile, d, verbose=verbose, compile_message=compile_message, use_cache=use_cache, create_local_c_file=False) return d['f']