[Scipy-svn] r4508 - trunk/scipy/sandbox/mkufunc

scipy-svn@scip... scipy-svn@scip...
Mon Jun 30 19:35:15 CDT 2008


Author: ilan
Date: 2008-06-30 19:35:15 -0500 (Mon, 30 Jun 2008)
New Revision: 4508

Removed:
   trunk/scipy/sandbox/mkufunc/driver.py
   trunk/scipy/sandbox/mkufunc/interactive.py
   trunk/scipy/sandbox/mkufunc/pypy_head.h
   trunk/scipy/sandbox/mkufunc/test_func_hash.py
   trunk/scipy/sandbox/mkufunc/test_mkufunc.py
   trunk/scipy/sandbox/mkufunc/test_speed.py
Log:
Moved into mkufunc/

Deleted: trunk/scipy/sandbox/mkufunc/driver.py
===================================================================
--- trunk/scipy/sandbox/mkufunc/driver.py	2008-07-01 00:32:12 UTC (rev 4507)
+++ trunk/scipy/sandbox/mkufunc/driver.py	2008-07-01 00:35:15 UTC (rev 4508)
@@ -1,728 +0,0 @@
-import sys, os
-
-from pypy.translator.translator import TranslationContext, graphof
-from pypy.translator.tool.taskengine import SimpleTaskEngine
-from pypy.translator.goal import query
-from pypy.translator.goal.timing import Timer
-from pypy.annotation import model as annmodel
-from pypy.annotation.listdef import s_list_of_strings
-from pypy.annotation import policy as annpolicy
-from py.compat import optparse
-from pypy.tool.udir import udir
-
-import py
-from pypy.tool.ansi_print import ansi_log
-log = py.log.Producer("translation")
-py.log.setconsumer("translation", ansi_log)
-
-DEFAULTS = {
-  'translation.gc': 'ref',
-  'translation.cc': None,
-  'translation.profopt': None,
-
-  'translation.thread': False, # influences GC policy
-
-  'translation.stackless': False,
-  'translation.debug': True,
-  'translation.insist': False,
-  'translation.backend': 'c',
-  'translation.fork_before': None,
-  'translation.backendopt.raisingop2direct_call' : False,
-  'translation.backendopt.merge_if_blocks': True,
-}
-
-
-def taskdef(taskfunc, deps, title, new_state=None, expected_states=[],
-            idemp=False, earlycheck=None):
-    taskfunc.task_deps = deps
-    taskfunc.task_title = title
-    taskfunc.task_newstate = None
-    taskfunc.task_expected_states = expected_states
-    taskfunc.task_idempotent = idemp
-    taskfunc.task_earlycheck = earlycheck
-    return taskfunc
-
-# TODO:
-# sanity-checks using states
-
-_BACKEND_TO_TYPESYSTEM = {
-    'c': 'lltype',
-    'llvm': 'lltype'
-}
-
-def backend_to_typesystem(backend):
-    return _BACKEND_TO_TYPESYSTEM.get(backend, 'ootype')
-
-# set of translation steps to profile
-PROFILE = set([])
-
-class Instrument(Exception):
-    pass
-
-
-class ProfInstrument(object):
-    name = "profinstrument"
-    def __init__(self, datafile, compiler):
-        self.datafile = datafile
-        self.compiler = compiler
-
-    def first(self):
-        self.compiler._build()
-
-    def probe(self, exe, args):
-        from py.compat import subprocess
-        env = os.environ.copy()
-        env['_INSTRUMENT_COUNTERS'] = str(self.datafile)
-        subprocess.call("'%s' %s" % (exe, args), env=env, shell=True)
-        
-    def after(self):
-        # xxx
-        os._exit(0)
-
-
-class TranslationDriver(SimpleTaskEngine):
-
-    def __init__(self, setopts=None, default_goal=None,
-                 disable=[],
-                 exe_name=None, extmod_name=None,
-                 config=None, overrides=None):
-        self.timer = Timer()
-        SimpleTaskEngine.__init__(self)
-
-        self.log = log
-
-        if config is None:
-            from pypy.config.pypyoption import get_pypy_config
-            config = get_pypy_config(DEFAULTS, translating=True)
-        self.config = config
-        if overrides is not None:
-            self.config.override(overrides)
-
-        if setopts is not None:
-            self.config.set(**setopts)
-        
-        self.exe_name = exe_name
-        self.extmod_name = extmod_name
-
-        self.done = {}
-
-        self.disable(disable)
-
-        if default_goal:
-            default_goal, = self.backend_select_goals([default_goal])
-            if default_goal in self._maybe_skip():
-                default_goal = None
-        
-        self.default_goal = default_goal
-        self.extra_goals = []
-        self.exposed = []
-
-        # expose tasks
-        def expose_task(task, backend_goal=None):
-            if backend_goal is None:
-                backend_goal = task
-            def proc():
-                return self.proceed(backend_goal)
-            self.exposed.append(task)
-            setattr(self, task, proc)
-
-        backend, ts = self.get_backend_and_type_system()
-        for task in self.tasks:
-            explicit_task = task
-            parts = task.split('_')
-            if len(parts) == 1:
-                if task in ('annotate'):
-                    expose_task(task)
-            else:
-                task, postfix = parts
-                if task in ('rtype', 'backendopt', 'llinterpret',
-                            'prehannotatebackendopt', 'hintannotate',
-                            'timeshift'):
-                    if ts:
-                        if ts == postfix:
-                            expose_task(task, explicit_task)
-                    else:
-                        expose_task(explicit_task)
-                elif task in ('source', 'compile', 'run'):
-                    if backend:
-                        if backend == postfix:
-                            expose_task(task, explicit_task)
-                    elif ts:
-                        if ts == backend_to_typesystem(postfix):
-                            expose_task(explicit_task)
-                    else:
-                        expose_task(explicit_task)
-
-    def set_extra_goals(self, goals):
-        self.extra_goals = goals
-
-    def get_info(self): # XXX more?
-        d = {'backend': self.config.translation.backend}
-        return d
-
-    def get_backend_and_type_system(self):
-        type_system = self.config.translation.type_system
-        backend = self.config.translation.backend
-        return backend, type_system
-
-    def backend_select_goals(self, goals):
-        backend, ts = self.get_backend_and_type_system()
-        postfixes = [''] + ['_'+p for p in (backend, ts) if p]
-        l = []
-        for goal in goals:
-            for postfix in postfixes:
-                cand = "%s%s" % (goal, postfix)
-                if cand in self.tasks:
-                    new_goal = cand
-                    break
-            else:
-                raise Exception, "cannot infer complete goal from: %r" % goal 
-            l.append(new_goal)
-        return l
-
-    def disable(self, to_disable):
-        self._disabled = to_disable
-
-    def _maybe_skip(self):
-        maybe_skip = []
-        if self._disabled:
-             for goal in  self.backend_select_goals(self._disabled):
-                 maybe_skip.extend(self._depending_on_closure(goal))
-        return dict.fromkeys(maybe_skip).keys()
-
-
-    def setup(self, entry_point, inputtypes, policy=None, extra={}, empty_translator=None):
-        standalone = inputtypes is None
-        self.standalone = standalone
-
-        if standalone:
-            inputtypes = [s_list_of_strings]
-        self.inputtypes = inputtypes
-
-        if policy is None:
-            policy = annpolicy.AnnotatorPolicy()
-        if standalone:
-            policy.allow_someobjects = False
-        self.policy = policy
-
-        self.extra = extra
-
-        if empty_translator:
-            translator = empty_translator
-        else:
-            translator = TranslationContext(config=self.config)
-
-        self.entry_point = entry_point
-        self.translator = translator
-        self.libdef = None
-
-        self.translator.driver_instrument_result = self.instrument_result
-
-    def setup_library(self, libdef, policy=None, extra={}, empty_translator=None):
-        self.setup(None, None, policy, extra, empty_translator)
-        self.libdef = libdef
-
-    def instrument_result(self, args):
-        backend, ts = self.get_backend_and_type_system()
-        if backend != 'c' or sys.platform == 'win32':
-            raise Exception("instrumentation requires the c backend"
-                            " and unix for now")
-        from pypy.tool.udir import udir
-        
-        datafile = udir.join('_instrument_counters')
-        makeProfInstrument = lambda compiler: ProfInstrument(datafile, compiler)
-
-        pid = os.fork()
-        if pid == 0:
-            # child compiling and running with instrumentation
-            self.config.translation.instrument = True
-            self.config.translation.instrumentctl = (makeProfInstrument,
-                                                     args)
-            raise Instrument
-        else:
-            pid, status = os.waitpid(pid, 0)
-            if os.WIFEXITED(status):
-                status = os.WEXITSTATUS(status)
-                if status != 0:
-                    raise Exception, "instrumentation child failed: %d" % status
-            else:
-                raise Exception, "instrumentation child aborted"
-            import array, struct
-            n = datafile.size()//struct.calcsize('L')
-            datafile = datafile.open('rb')
-            counters = array.array('L')
-            counters.fromfile(datafile, n)
-            datafile.close()
-            return counters
-
-    def info(self, msg):
-        log.info(msg)
-
-    def _profile(self, goal, func):
-        from cProfile import Profile
-        from pypy.tool.lsprofcalltree import KCacheGrind
-        d = {'func':func}
-        prof = Profile()
-        prof.runctx("res = func()", globals(), d)
-        KCacheGrind(prof).output(open(goal + ".out", "w"))
-        return d['res']
-
-    def _do(self, goal, func, *args, **kwds):
-        title = func.task_title
-        if goal in self.done:
-            self.log.info("already done: %s" % title)
-            return
-        else:
-            self.log.info("%s..." % title)
-        self.timer.start_event(goal)
-        try:
-            instrument = False
-            try:
-                if goal in PROFILE:
-                    res = self._profile(goal, func)
-                else:
-                    res = func()
-            except Instrument:
-                instrument = True
-            if not func.task_idempotent:
-                self.done[goal] = True
-            if instrument:
-                self.proceed('compile')
-                assert False, 'we should not get here'
-        finally:
-            self.timer.end_event(goal)
-        return res
-
-    def task_annotate(self):
-        # includes annotation and annotatation simplifications
-        translator = self.translator
-        policy = self.policy
-        self.log.info('with policy: %s.%s' %
-                      (policy.__class__.__module__, policy.__class__.__name__))
-        
-        annmodel.DEBUG = self.config.translation.debug
-        annotator = translator.buildannotator(policy=policy)
-
-        if self.entry_point:
-            s = annotator.build_types(self.entry_point, self.inputtypes)
-
-            self.sanity_check_annotation()
-            if self.standalone and s.knowntype != int:
-                raise Exception("stand-alone program entry point must return an "
-                                "int (and not, e.g., None or always raise an "
-                                "exception).")
-            annotator.simplify()
-            return s
-        else:
-            assert self.libdef is not None
-            for func, inputtypes in self.libdef.functions:
-                annotator.build_types(func, inputtypes)
-            self.sanity_check_annotation()
-            annotator.simplify()
-    #
-    task_annotate = taskdef(task_annotate, [], "Annotating&simplifying")
-
-
-    def sanity_check_annotation(self):
-        translator = self.translator
-        irreg = query.qoutput(query.check_exceptblocks_qgen(translator))
-        if irreg:
-            self.log.info("Some exceptblocks seem insane")
-
-        lost = query.qoutput(query.check_methods_qgen(translator))
-        assert not lost, "lost methods, something gone wrong with the annotation of method defs"
-
-        so = query.qoutput(query.polluted_qgen(translator))
-        tot = len(translator.graphs)
-        percent = int(tot and (100.0*so / tot) or 0)
-        # if there are a few SomeObjects even if the policy doesn't allow
-        # them, it means that they were put there in a controlled way
-        # and then it's not a warning.
-        if not translator.annotator.policy.allow_someobjects:
-            pr = self.log.info
-        elif percent == 0:
-            pr = self.log.info
-        else:
-            pr = log.WARNING
-        pr("-- someobjectness %2d%% (%d of %d functions polluted by SomeObjects)" % (percent, so, tot))
-
-
-
-    def task_rtype_lltype(self):
-        rtyper = self.translator.buildrtyper(type_system='lltype')
-        insist = not self.config.translation.insist
-        rtyper.specialize(dont_simplify_again=True,
-                          crash_on_first_typeerror=insist)
-    #
-    task_rtype_lltype = taskdef(task_rtype_lltype, ['annotate'], "RTyping")
-    RTYPE = 'rtype_lltype'
-
-    def task_rtype_ootype(self):
-        # Maybe type_system should simply be an option used in task_rtype
-        insist = not self.config.translation.insist
-        rtyper = self.translator.buildrtyper(type_system="ootype")
-        rtyper.specialize(dont_simplify_again=True,
-                          crash_on_first_typeerror=insist)
-    #
-    task_rtype_ootype = taskdef(task_rtype_ootype, ['annotate'], "ootyping")
-    OOTYPE = 'rtype_ootype'
-
-    def task_prehannotatebackendopt_lltype(self):
-        from pypy.translator.backendopt.all import backend_optimizations
-        backend_optimizations(self.translator,
-                              inline_threshold=0,
-                              merge_if_blocks=True,
-                              constfold=True,
-                              raisingop2direct_call=False,
-                              remove_asserts=True)
-    #
-    task_prehannotatebackendopt_lltype = taskdef(
-        task_prehannotatebackendopt_lltype,
-        [RTYPE],
-        "Backendopt before Hint-annotate")
-
-    def task_hintannotate_lltype(self):
-        from pypy.jit.hintannotator.annotator import HintAnnotator
-        from pypy.jit.hintannotator.model import OriginFlags
-        from pypy.jit.hintannotator.model import SomeLLAbstractConstant
-
-        get_portal = self.extra['portal']
-        PORTAL, POLICY = get_portal(self)
-        t = self.translator
-        self.portal_graph = graphof(t, PORTAL)
-
-        hannotator = HintAnnotator(base_translator=t, policy=POLICY)
-        self.hint_translator = hannotator.translator
-        hs = hannotator.build_types(self.portal_graph,
-                                    [SomeLLAbstractConstant(v.concretetype,
-                                                            {OriginFlags(): True})
-                                     for v in self.portal_graph.getargs()])
-        count = hannotator.bookkeeper.nonstuboriggraphcount
-        stubcount = hannotator.bookkeeper.stuboriggraphcount
-        self.log.info("The hint-annotator saw %d graphs"
-                      " (and made stubs for %d graphs)." % (count, stubcount))
-        n = len(list(hannotator.translator.graphs[0].iterblocks()))
-        self.log.info("portal has %d blocks" % n)
-        self.hannotator = hannotator
-    #
-    task_hintannotate_lltype = taskdef(task_hintannotate_lltype,
-                                       ['prehannotatebackendopt_lltype'],
-                                       "Hint-annotate")
-
-    def task_timeshift_lltype(self):
-        from pypy.jit.timeshifter.hrtyper import HintRTyper
-        from pypy.jit.codegen import detect_cpu
-        cpu = detect_cpu.autodetect()
-        if cpu == 'i386':
-            from pypy.jit.codegen.i386.rgenop import RI386GenOp as RGenOp
-            RGenOp.MC_SIZE = 32 * 1024 * 1024
-        elif cpu == 'ppc':
-            from pypy.jit.codegen.ppc.rgenop import RPPCGenOp as RGenOp
-            RGenOp.MC_SIZE = 32 * 1024 * 1024
-        else:
-            raise Exception('Unsuported cpu %r'%cpu)
-
-        del self.hint_translator
-        ha = self.hannotator
-        t = self.translator
-        # make the timeshifted graphs
-        hrtyper = HintRTyper(ha, t.rtyper, RGenOp)
-        hrtyper.specialize(origportalgraph=self.portal_graph, view=False)
-    #
-    task_timeshift_lltype = taskdef(task_timeshift_lltype,
-                             ["hintannotate_lltype"],
-                             "Timeshift")
-
-    def task_backendopt_lltype(self):
-        from pypy.translator.backendopt.all import backend_optimizations
-        backend_optimizations(self.translator)
-    #
-    task_backendopt_lltype = taskdef(task_backendopt_lltype,
-                                     [RTYPE,
-                                      '??timeshift_lltype'],
-                                     "lltype back-end optimisations")
-    BACKENDOPT = 'backendopt_lltype'
-
-    def task_backendopt_ootype(self):
-        from pypy.translator.backendopt.all import backend_optimizations
-        backend_optimizations(self.translator)
-    #
-    task_backendopt_ootype = taskdef(task_backendopt_ootype, 
-                                        [OOTYPE], "ootype back-end optimisations")
-    OOBACKENDOPT = 'backendopt_ootype'
-
-
-    def task_stackcheckinsertion_lltype(self):
-        from pypy.translator.transform import insert_ll_stackcheck
-        count = insert_ll_stackcheck(self.translator)
-        self.log.info("inserted %d stack checks." % (count,))
-        
-    task_stackcheckinsertion_lltype = taskdef(
-        task_stackcheckinsertion_lltype,
-        ['?'+BACKENDOPT, RTYPE, 'annotate'],
-        "inserting stack checks")
-    STACKCHECKINSERTION = 'stackcheckinsertion_lltype'
-
-    def possibly_check_for_boehm(self):
-        if self.config.translation.gc == "boehm":
-            from pypy.translator.tool.cbuild import check_boehm_presence
-            from pypy.translator.tool.cbuild import CompilationError
-            try:
-                check_boehm_presence(noerr=False)
-            except CompilationError, e:
-                i = 'Boehm GC not installed.  Try e.g. "translate.py --gc=hybrid"'
-                raise CompilationError('%s\n--------------------\n%s' % (e, i))
-
-    def task_database_c(self):
-        translator = self.translator
-        if translator.annotator is not None:
-            translator.frozen = True
-
-        standalone = self.standalone
-
-        if standalone:
-            from pypy.translator.c.genc import CStandaloneBuilder as CBuilder
-        else:
-            from pypy.translator.c.genc import CExtModuleBuilder as CBuilder
-        cbuilder = CBuilder(self.translator, self.entry_point,
-                            config=self.config)
-        cbuilder.stackless = self.config.translation.stackless
-        if not standalone:     # xxx more messy
-            cbuilder.modulename = self.extmod_name
-        database = cbuilder.build_database()
-        self.log.info("database for generating C source was created")
-        self.cbuilder = cbuilder
-        self.database = database
-    #
-    task_database_c = taskdef(task_database_c,
-                            [STACKCHECKINSERTION, '?'+BACKENDOPT, RTYPE, '?annotate'], 
-                            "Creating database for generating c source",
-                            earlycheck = possibly_check_for_boehm)
-    
-    def task_source_c(self):  # xxx messy
-        translator = self.translator
-        cbuilder = self.cbuilder
-        database = self.database
-        c_source_filename = cbuilder.generate_source(database)
-        self.log.info("written: %s" % (c_source_filename,))
-        self.c_source_filename = str(c_source_filename)
-    #
-    task_source_c = taskdef(task_source_c, ['database_c'], "Generating c source")
-
-    def task_compile_c(self): # xxx messy
-        cbuilder = self.cbuilder
-        cbuilder.compile()
-        
-        if self.standalone:
-            self.c_entryp = cbuilder.executable_name
-            self.create_exe()
-        else:
-            self.c_entryp = cbuilder.get_entry_point()
-    #
-    task_compile_c = taskdef(task_compile_c, ['source_c'], "Compiling c source")
-    
-    
-    def task_run_c(self):
-        self.backend_run('c')
-    #
-    task_run_c = taskdef(task_run_c, ['compile_c'], 
-                         "Running compiled c source",
-                         idemp=True)
-
-    def task_llinterpret_lltype(self):
-        from pypy.rpython.llinterp import LLInterpreter
-        py.log.setconsumer("llinterp operation", None)
-        
-        translator = self.translator
-        interp = LLInterpreter(translator.rtyper)
-        bk = translator.annotator.bookkeeper
-        graph = bk.getdesc(self.entry_point).getuniquegraph()
-        v = interp.eval_graph(graph,
-                              self.extra.get('get_llinterp_args',
-                                             lambda: [])())
-
-        log.llinterpret.event("result -> %s" % v)
-    #
-    task_llinterpret_lltype = taskdef(task_llinterpret_lltype, 
-                                      [STACKCHECKINSERTION, '?'+BACKENDOPT, RTYPE], 
-                                      "LLInterpreting")
-
-    def task_source_llvm(self):
-        translator = self.translator
-        if translator.annotator is None:
-            raise ValueError, "llvm requires annotation."
-
-        from pypy.translator.llvm import genllvm
-
-        self.llvmgen = genllvm.GenLLVM(translator, self.standalone)
-
-        llvm_filename = self.llvmgen.gen_source(self.entry_point)
-        self.log.info("written: %s" % (llvm_filename,))
-    #
-    task_source_llvm = taskdef(task_source_llvm, 
-                               [STACKCHECKINSERTION, BACKENDOPT, RTYPE], 
-                               "Generating llvm source")
-
-    def task_compile_llvm(self):
-        gen = self.llvmgen
-        if self.standalone:
-            exe_name = (self.exe_name or 'testing') % self.get_info()
-            self.c_entryp = gen.compile_standalone(exe_name)
-            self.create_exe()
-        else:
-            self.c_module, self.c_entryp = gen.compile_module()
-    #
-    task_compile_llvm = taskdef(task_compile_llvm, 
-                                ['source_llvm'], 
-                                "Compiling llvm source")
-
-    def task_run_llvm(self):
-        self.backend_run('llvm')
-    #
-    task_run_llvm = taskdef(task_run_llvm, ['compile_llvm'], 
-                            "Running compiled llvm source",
-                            idemp=True)
-
-    def task_source_js(self):
-        from pypy.translator.js.js import JS
-        self.gen = JS(self.translator, functions=[self.entry_point],
-                      stackless=self.config.translation.stackless)
-        filename = self.gen.write_source()
-        self.log.info("Wrote %s" % (filename,))
-    task_source_js = taskdef(task_source_js, 
-                        [OOTYPE],
-                        'Generating Javascript source')
-
-    def task_compile_js(self):
-        pass
-    task_compile_js = taskdef(task_compile_js, ['source_js'],
-                              'Skipping Javascript compilation')
-
-    def task_run_js(self):
-        pass
-    task_run_js = taskdef(task_run_js, ['compile_js'],
-                              'Please manually run the generated code')
-
-    def task_source_cli(self):
-        from pypy.translator.cli.gencli import GenCli
-        from pypy.translator.cli.entrypoint import get_entrypoint
-
-        if self.entry_point is not None: # executable mode
-            entry_point_graph = self.translator.graphs[0]
-            entry_point = get_entrypoint(entry_point_graph)
-        else:
-            # library mode
-            assert self.libdef is not None
-            bk = self.translator.annotator.bookkeeper
-            entry_point = self.libdef.get_entrypoint(bk)
-
-        self.gen = GenCli(udir, self.translator, entry_point, config=self.config)
-        filename = self.gen.generate_source()
-        self.log.info("Wrote %s" % (filename,))
-    task_source_cli = taskdef(task_source_cli, ["?" + OOBACKENDOPT, OOTYPE],
-                             'Generating CLI source')
-
-    def task_compile_cli(self):
-        from pypy.translator.oosupport.support import unpatch_os
-        from pypy.translator.cli.test.runtest import CliFunctionWrapper
-        filename = self.gen.build_exe()
-        self.c_entryp = CliFunctionWrapper(filename)
-        # restore original os values
-        if hasattr(self, 'old_cli_defs'):
-            unpatch_os(self.old_cli_defs)
-        
-        self.log.info("Compiled %s" % filename)
-        if self.standalone and self.exe_name:
-            self.copy_cli_exe()
-    task_compile_cli = taskdef(task_compile_cli, ['source_cli'],
-                              'Compiling CLI source')
-
-    def task_run_cli(self):
-        pass
-    task_run_cli = taskdef(task_run_cli, ['compile_cli'],
-                              'XXX')
-    
-    def task_source_jvm(self):
-        from pypy.translator.jvm.genjvm import GenJvm
-        from pypy.translator.jvm.node import EntryPoint
-
-        entry_point_graph = self.translator.graphs[0]
-        is_func = not self.standalone
-        entry_point = EntryPoint(entry_point_graph, is_func, is_func)
-        self.gen = GenJvm(udir, self.translator, entry_point)
-        self.jvmsource = self.gen.generate_source()
-        self.log.info("Wrote JVM code")
-    task_source_jvm = taskdef(task_source_jvm, ["?" + OOBACKENDOPT, OOTYPE],
-                             'Generating JVM source')
-
-    def task_compile_jvm(self):
-        from pypy.translator.oosupport.support import unpatch_os
-        from pypy.translator.jvm.test.runtest import JvmGeneratedSourceWrapper
-        self.jvmsource.compile()
-        self.c_entryp = JvmGeneratedSourceWrapper(self.jvmsource)
-        # restore original os values
-        if hasattr(self, 'old_cli_defs'):
-            unpatch_os(self.old_cli_defs)
-        self.log.info("Compiled JVM source")
-        if self.standalone and self.exe_name:
-            self.copy_jvm_jar()
-    task_compile_jvm = taskdef(task_compile_jvm, ['source_jvm'],
-                              'Compiling JVM source')
-
-    def task_run_jvm(self):
-        pass
-    task_run_jvm = taskdef(task_run_jvm, ['compile_jvm'],
-                           'XXX')
-
-    def proceed(self, goals):
-        if not goals:
-            if self.default_goal:
-                goals = [self.default_goal]
-            else:
-                self.log.info("nothing to do")
-                return
-        elif isinstance(goals, str):
-            goals = [goals]
-        goals.extend(self.extra_goals)
-        goals = self.backend_select_goals(goals)
-        return self._execute(goals, task_skip = self._maybe_skip())
-
-    def from_targetspec(targetspec_dic, config=None, args=None,
-                        empty_translator=None,
-                        disable=[],
-                        default_goal=None):
-        if args is None:
-            args = []
-
-        driver = TranslationDriver(config=config, default_goal=default_goal,
-                                   disable=disable)
-        # patch some attributes of the os module to make sure they
-        # have the same value on every platform.
-        backend, ts = driver.get_backend_and_type_system()
-        if backend in ('cli', 'jvm'):
-            from pypy.translator.oosupport.support import patch_os
-            driver.old_cli_defs = patch_os()
-        
-        target = targetspec_dic['target']
-        spec = target(driver, args)
-
-        try:
-            entry_point, inputtypes, policy = spec
-        except ValueError:
-            entry_point, inputtypes = spec
-            policy = None
-
-        driver.setup(entry_point, inputtypes, 
-                     policy=policy, 
-                     extra=targetspec_dic,
-                     empty_translator=empty_translator)
-
-        return driver
-
-    from_targetspec = staticmethod(from_targetspec)
-
-    def prereq_checkpt_rtype(self):
-        assert 'pypy.rpython.rmodel' not in sys.modules, (
-            "cannot fork because the rtyper has already been imported")
-    prereq_checkpt_rtype_lltype = prereq_checkpt_rtype
-    prereq_checkpt_rtype_ootype = prereq_checkpt_rtype    

Deleted: trunk/scipy/sandbox/mkufunc/interactive.py
===================================================================
--- trunk/scipy/sandbox/mkufunc/interactive.py	2008-07-01 00:32:12 UTC (rev 4507)
+++ trunk/scipy/sandbox/mkufunc/interactive.py	2008-07-01 00:35:15 UTC (rev 4508)
@@ -1,115 +0,0 @@
-import driver
-
-from pypy.translator.translator import TranslationContext
-
-
-DEFAULTS = {
-  'translation.backend': None,
-  'translation.type_system': None,
-  'translation.verbose': False,
-}
-
-class Translation(object):
-
-    def __init__(self, entry_point, argtypes=None, **kwds):
-        self.driver = driver.TranslationDriver(overrides=DEFAULTS)
-        self.config = self.driver.config
-
-        self.entry_point = entry_point
-        self.context = TranslationContext(config=self.config)
-        
-        # hook into driver events
-        driver_own_event = self.driver._event
-        def _event(kind, goal, func):
-            self.driver_event(kind, goal, func)
-            driver_own_event(kind, goal, func)
-        self.driver._event = _event
-        self.driver_setup = False
-        
-        self.update_options(argtypes, kwds)
-        # for t.view() to work just after construction
-        graph = self.context.buildflowgraph(entry_point)
-        self.context._prebuilt_graphs[entry_point] = graph
-
-    def driver_event(self, kind, goal, func):
-        if kind == 'pre':
-             self.ensure_setup()
-            
-    def ensure_setup(self, argtypes=None, policy=None, standalone=False):
-        if not self.driver_setup:
-            if standalone:
-                assert argtypes is None
-            else:
-                if argtypes is None:
-                    argtypes = []
-            self.driver.setup(self.entry_point, argtypes, policy,
-                              empty_translator=self.context)
-            self.ann_argtypes = argtypes
-            self.ann_policy = policy
-            self.driver_setup = True
-        else:
-            # check consistency
-            if standalone:
-                assert argtypes is None
-                assert self.ann_argtypes is None
-            elif argtypes is not None and argtypes != self.ann_argtypes:
-                raise Exception("inconsistent argtype supplied")
-            if policy is not None and policy != self.ann_policy:
-                raise Exception("inconsistent annotation polish supplied")
-
-    def update_options(self, argtypes, kwds):
-        if argtypes or kwds.get('policy') or kwds.get('standalone'):
-            self.ensure_setup(argtypes, kwds.get('policy'),
-                                        kwds.get('standalone'))
-        kwds.pop('policy', None)
-        kwds.pop('standalone', None)
-        self.config.translation.set(**kwds)
-
-    def ensure_opt(self, name, value=None, fallback=None):
-        if value is not None:
-            self.update_options(None, {name: value})
-            return value
-        val = getattr(self.config.translation, name, None)
-        if fallback is not None and val is None:
-            self.update_options(None, {name: fallback})
-            return fallback
-        if val is not None:
-            return val
-        raise Exception(
-              "the %r option should have been specified at this point" %name)
-
-    def ensure_type_system(self, type_system=None):
-        if self.config.translation.backend is not None:
-            return self.ensure_opt('type_system')
-        return self.ensure_opt('type_system', type_system, 'lltype')
-        
-    def ensure_backend(self, backend=None):
-        backend = self.ensure_opt('backend', backend)
-        self.ensure_type_system()
-        return backend
-
-    # backend independent
-
-    def annotate(self, argtypes=None, **kwds):
-        self.update_options(argtypes, kwds)
-        return self.driver.annotate()
-
-    # type system dependent
-
-    def rtype(self, argtypes=None, **kwds):
-        self.update_options(argtypes, kwds)
-        ts = self.ensure_type_system()
-        return getattr(self.driver, 'rtype_'+ts)()        
-
-    # backend depedent
-
-    def source(self, argtypes=None, **kwds):
-        self.update_options(argtypes, kwds)
-        backend = self.ensure_backend()
-        self.driver.source_c()
-       
-    def compile(self, argtypes=None, **kwds):
-        self.update_options(argtypes, kwds)
-        backend = self.ensure_backend()
-        self.driver.compile_c()
-        return self.driver.c_entryp

Deleted: trunk/scipy/sandbox/mkufunc/pypy_head.h
===================================================================
--- trunk/scipy/sandbox/mkufunc/pypy_head.h	2008-07-01 00:32:12 UTC (rev 4507)
+++ trunk/scipy/sandbox/mkufunc/pypy_head.h	2008-07-01 00:35:15 UTC (rev 4508)
@@ -1,381 +0,0 @@
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-
-/* ================================================== g_prerequisite.h === */
-
-typedef unsigned char bool_t;
-
-/* ================================================== exception.h ======== */
-
-#define RPY_DEBUG_RETURN()        /* nothing */
-
-
-/* ================================================== int.h ============== */
-
-/*** unary operations ***/
-
-#define OP_INT_IS_TRUE(x,r)   OP_INT_NE(x,0,r)
-
-#define OP_INT_INVERT(x,r)    r = ~((x))
-
-#define OP_INT_NEG(x,r)    r = -(x)
-
-#define OP_INT_NEG_OVF(x,r) \
-    if ((x) == LONG_MIN) FAIL_OVF("integer negate"); \
-	OP_INT_NEG(x,r)
-#define OP_LLONG_NEG_OVF(x,r) \
-    if ((x) == LLONG_MIN) FAIL_OVF("integer negate"); \
-	OP_LLONG_NEG(x,r)
-
-#define OP_INT_ABS(x,r)    r = (x) >= 0 ? x : -(x)
-
-#define OP_INT_ABS_OVF(x,r) \
-    if ((x) == LONG_MIN) FAIL_OVF("integer absolute"); \
-	OP_INT_ABS(x,r)
-#define OP_LLONG_ABS_OVF(x,r) \
-    if ((x) == LLONG_MIN) FAIL_OVF("integer absolute"); \
-	OP_LLONG_ABS(x,r)
-
-/***  binary operations ***/
-
-#define OP_INT_EQ(x,y,r)	  r = ((x) == (y))
-#define OP_INT_NE(x,y,r)	  r = ((x) != (y))
-#define OP_INT_LE(x,y,r)	  r = ((x) <= (y))
-#define OP_INT_GT(x,y,r)	  r = ((x) >  (y))
-#define OP_INT_LT(x,y,r)	  r = ((x) <  (y))
-#define OP_INT_GE(x,y,r)	  r = ((x) >= (y))
-
-/* addition, subtraction */
-
-#define OP_INT_ADD(x,y,r)     r = (x) + (y)
-
-#define OP_INT_ADD_OVF(x,y,r) \
-	OP_INT_ADD(x,y,r); \
-	if ((r^(x)) >= 0 || (r^(y)) >= 0); \
-	else FAIL_OVF("integer addition")
-
-#define OP_INT_ADD_NONNEG_OVF(x,y,r)  /* y can be assumed >= 0 */ \
-    OP_INT_ADD(x,y,r); \
-    if (r >= (x)); \
-    else FAIL_OVF("integer addition")
-/* XXX can a C compiler be too clever and think it can "prove" that
- * r >= x always hold above? */
-
-#define OP_INT_SUB(x,y,r)     r = (x) - (y)
-
-#define OP_INT_SUB_OVF(x,y,r) \
-	OP_INT_SUB(x,y,r); \
-	if ((r^(x)) >= 0 || (r^~(y)) >= 0); \
-	else FAIL_OVF("integer subtraction")
-
-#define OP_INT_MUL(x,y,r)     r = (x) * (y)
-
-#if defined(HAVE_LONG_LONG) && SIZE_OF_LONG_LONG < SIZE_OF_LONG
-#  define OP_INT_MUL_OVF_LL      1
-#lse
-#  define OP_INT_MUL_OVF_LL      0
-#endif
-
-#if !OP_INT_MUL_OVF_LL
-
-#define OP_INT_MUL_OVF(x,y,r) \
-	if (op_int_mul_ovf(x,y,&r)); \
-	else FAIL_OVF("integer multiplication")
-
-#else
-
-#define OP_INT_MUL_OVF(x,y,r) \
-	{ \
-		PY_LONG_LONG lr = (PY_LONG_LONG)(x) * (PY_LONG_LONG)(y); \
-		r = (long)lr; \
-		if ((PY_LONG_LONG)r == lr); \
-		else FAIL_OVF("integer multiplication"); \
-	}
-#endif
-
-/* shifting */
-
-/* NB. shifting has same limitations as C: the shift count must be
-       >= 0 and < LONG_BITS. */
-#define OP_INT_RSHIFT(x,y,r)    r = Py_ARITHMETIC_RIGHT_SHIFT(long, x, y)
-#define OP_UINT_RSHIFT(x,y,r)   r = (x) >> (y)
-#define OP_LLONG_RSHIFT(x,y,r)  r = Py_ARITHMETIC_RIGHT_SHIFT(PY_LONG_LONG,x,y)
-#define OP_ULLONG_RSHIFT(x,y,r) r = (x) >> (y)
-
-#define OP_INT_LSHIFT(x,y,r)    r = (x) << (y)
-#define OP_UINT_LSHIFT(x,y,r)   r = (x) << (y)
-#define OP_LLONG_LSHIFT(x,y,r)  r = (x) << (y)
-#define OP_ULLONG_LSHIFT(x,y,r) r = (x) << (y)
-
-#define OP_INT_LSHIFT_OVF(x,y,r) \
-	OP_INT_LSHIFT(x,y,r); \
-	if ((x) != Py_ARITHMETIC_RIGHT_SHIFT(long, r, (y))) \
-		FAIL_OVF("x<<y losing bits or changing sign")
-
-/* the safe value-checking version of the above macros */
-
-#define OP_INT_RSHIFT_VAL(x,y,r) \
-	if ((y) >= 0) { OP_INT_RSHIFT(x,y,r); } \
-	else FAIL_VAL("negative shift count")
-#define OP_LLONG_RSHIFT_VAL(x,y,r) \
-	if ((y) >= 0) { OP_LLONG_RSHIFT(x,y,r); } \
-	else FAIL_VAL("negative shift count")
-
-#define OP_INT_LSHIFT_VAL(x,y,r) \
-	if ((y) >= 0) { OP_INT_LSHIFT(x,y,r); } \
-	else FAIL_VAL("negative shift count")
-#define OP_LLONG_LSHIFT_VAL(x,y,r) \
-	if ((y) >= 0) { OP_LLONG_LSHIFT(x,y,r); } \
-	else FAIL_VAL("negative shift count")
-
-#define OP_INT_LSHIFT_OVF_VAL(x,y,r) \
-	if ((y) >= 0) { OP_INT_LSHIFT_OVF(x,y,r); } \
-	else FAIL_VAL("negative shift count")
-
-/* pff */
-#define OP_UINT_LSHIFT_VAL(x,y,r) \
-	if ((y) >= 0) { OP_UINT_LSHIFT(x,y,r); } \
-	else FAIL_VAL("negative shift count")
-#define OP_ULLONG_LSHIFT_VAL(x,y,r) \
-	if ((y) >= 0) { OP_ULLONG_LSHIFT(x,y,r); } \
-	else FAIL_VAL("negative shift count")
-
-#define OP_UINT_RSHIFT_VAL(x,y,r) \
-	if ((y) >= 0) { OP_UINT_RSHIFT(x,y,r); } \
-	else FAIL_VAL("negative shift count")
-#define OP_ULLONG_RSHIFT_VAL(x,y,r) \
-	if ((y) >= 0) { OP_ULLONG_RSHIFT(x,y,r); } \
-	else FAIL_VAL("negative shift count")
-
-
-/* floor division */
-
-#define OP_INT_FLOORDIV(x,y,r)    r = (x) / (y)
-#define OP_UINT_FLOORDIV(x,y,r)   r = (x) / (y)
-#define OP_LLONG_FLOORDIV(x,y,r)  r = (x) / (y)
-#define OP_ULLONG_FLOORDIV(x,y,r) r = (x) / (y)
-
-#define OP_INT_FLOORDIV_OVF(x,y,r) \
-	if ((y) == -1 && (x) == LONG_MIN) \
-            { FAIL_OVF("integer division"); } \
-        else OP_INT_FLOORDIV(x,y,r)
-
-#define OP_INT_FLOORDIV_ZER(x,y,r) \
-	if ((y)) { OP_INT_FLOORDIV(x,y,r); } \
-	else FAIL_ZER("integer division")
-#define OP_UINT_FLOORDIV_ZER(x,y,r) \
-	if ((y)) { OP_UINT_FLOORDIV(x,y,r); } \
-	else FAIL_ZER("unsigned integer division")
-#define OP_LLONG_FLOORDIV_ZER(x,y,r) \
-	if ((y)) { OP_LLONG_FLOORDIV(x,y,r); } \
-	else FAIL_ZER("integer division")
-#define OP_ULLONG_FLOORDIV_ZER(x,y,r) \
-	if ((y)) { OP_ULLONG_FLOORDIV(x,y,r); } \
-	else FAIL_ZER("unsigned integer division")
-
-#define OP_INT_FLOORDIV_OVF_ZER(x,y,r) \
-	if ((y)) { OP_INT_FLOORDIV_OVF(x,y,r); } \
-	else FAIL_ZER("integer division")
-
-/* modulus */
-
-#define OP_INT_MOD(x,y,r)     r = (x) % (y)
-#define OP_UINT_MOD(x,y,r)    r = (x) % (y)
-#define OP_LLONG_MOD(x,y,r)   r = (x) % (y)
-#define OP_ULLONG_MOD(x,y,r)  r = (x) % (y)
-
-#define OP_INT_MOD_OVF(x,y,r) \
-	if ((y) == -1 && (x) == LONG_MIN) \
-            { FAIL_OVF("integer modulo"); }\
-        else OP_INT_MOD(x,y,r)
-
-#define OP_INT_MOD_ZER(x,y,r) \
-	if ((y)) { OP_INT_MOD(x,y,r); } \
-	else FAIL_ZER("integer modulo")
-#define OP_UINT_MOD_ZER(x,y,r) \
-	if ((y)) { OP_UINT_MOD(x,y,r); } \
-	else FAIL_ZER("unsigned integer modulo")
-#define OP_LLONG_MOD_ZER(x,y,r) \
-	if ((y)) { OP_LLONG_MOD(x,y,r); } \
-	else FAIL_ZER("integer modulo")
-#define OP_ULLONG_MOD_ZER(x,y,r) \
-	if ((y)) { OP_ULLONG_MOD(x,y,r); } \
-	else FAIL_ZER("integer modulo")
-
-#define OP_INT_MOD_OVF_ZER(x,y,r) \
-	if ((y)) { OP_INT_MOD_OVF(x,y,r); } \
-	else FAIL_ZER("integer modulo")
-
-/* bit operations */
-
-#define OP_INT_AND(x,y,r)     r = (x) & (y)
-#define OP_INT_OR( x,y,r)     r = (x) | (y)
-#define OP_INT_XOR(x,y,r)     r = (x) ^ (y)
-
-/*** conversions ***/
-
-#define OP_CAST_BOOL_TO_INT(x,r)    r = (long)(x)
-#define OP_CAST_BOOL_TO_UINT(x,r)   r = (unsigned long)(x)
-#define OP_CAST_UINT_TO_INT(x,r)    r = (long)(x)
-#define OP_CAST_INT_TO_UINT(x,r)    r = (unsigned long)(x)
-#define OP_CAST_INT_TO_LONGLONG(x,r) r = (long long)(x)
-#define OP_CAST_CHAR_TO_INT(x,r)    r = (long)((unsigned char)(x))
-#define OP_CAST_INT_TO_CHAR(x,r)    r = (char)(x)
-#define OP_CAST_PTR_TO_INT(x,r)     r = (long)(x)    /* XXX */
-
-#define OP_TRUNCATE_LONGLONG_TO_INT(x,r) r = (long)(x)
-
-#define OP_CAST_UNICHAR_TO_INT(x,r)    r = (long)((unsigned long)(x)) /*?*/
-#define OP_CAST_INT_TO_UNICHAR(x,r)    r = (unsigned int)(x)
-
-/* bool operations */
-
-#define OP_BOOL_NOT(x, r) r = !(x)
-
-/* _________________ certain implementations __________________ */
-
-#if !OP_INT_MUL_OVF_LL
-/* adjusted from intobject.c, Python 2.3.3 */
-
-/* prototypes */
-
-int op_int_mul_ovf(long a, long b, long *longprod);
-
-/* implementations */
-
-#ifndef PYPY_NOT_MAIN_FILE
-
-int
-op_int_mul_ovf(long a, long b, long *longprod)
-{
-	double doubled_longprod;	/* (double)longprod */
-	double doubleprod;		/* (double)a * (double)b */
-
-	*longprod = a * b;
-	doubleprod = (double)a * (double)b;
-	doubled_longprod = (double)*longprod;
-
-	/* Fast path for normal case:  small multiplicands, and no info
-	   is lost in either method. */
-	if (doubled_longprod == doubleprod)
-		return 1;
-
-	/* Somebody somewhere lost info.  Close enough, or way off?  Note
-	   that a != 0 and b != 0 (else doubled_longprod == doubleprod == 0).
-	   The difference either is or isn't significant compared to the
-	   true value (of which doubleprod is a good approximation).
-	*/
-	{
-		const double diff = doubled_longprod - doubleprod;
-		const double absdiff = diff >= 0.0 ? diff : -diff;
-		const double absprod = doubleprod >= 0.0 ? doubleprod :
-							  -doubleprod;
-		/* absdiff/absprod <= 1/32 iff
-		   32 * absdiff <= absprod -- 5 good bits is "close enough" */
-		if (32.0 * absdiff <= absprod)
-			return 1;
-		return 0;
-	}
-}
-
-#endif /* PYPY_NOT_MAIN_FILE */
-
-#endif /* !OP_INT_MUL_OVF_LL */
-
-/* implementations */
-
-#define OP_UINT_IS_TRUE OP_INT_IS_TRUE
-#define OP_UINT_INVERT OP_INT_INVERT
-#define OP_UINT_ADD OP_INT_ADD
-#define OP_UINT_SUB OP_INT_SUB
-#define OP_UINT_MUL OP_INT_MUL
-#define OP_UINT_LT OP_INT_LT
-#define OP_UINT_LE OP_INT_LE
-#define OP_UINT_EQ OP_INT_EQ
-#define OP_UINT_NE OP_INT_NE
-#define OP_UINT_GT OP_INT_GT
-#define OP_UINT_GE OP_INT_GE
-#define OP_UINT_AND OP_INT_AND
-#define OP_UINT_OR OP_INT_OR
-#define OP_UINT_XOR OP_INT_XOR
-
-#define OP_LLONG_IS_TRUE OP_INT_IS_TRUE
-#define OP_LLONG_NEG     OP_INT_NEG
-#define OP_LLONG_ABS     OP_INT_ABS
-#define OP_LLONG_INVERT  OP_INT_INVERT
-
-#define OP_LLONG_ADD OP_INT_ADD
-#define OP_LLONG_SUB OP_INT_SUB
-#define OP_LLONG_MUL OP_INT_MUL
-#define OP_LLONG_LT  OP_INT_LT
-#define OP_LLONG_LE  OP_INT_LE
-#define OP_LLONG_EQ  OP_INT_EQ
-#define OP_LLONG_NE  OP_INT_NE
-#define OP_LLONG_GT  OP_INT_GT
-#define OP_LLONG_GE  OP_INT_GE
-#define OP_LLONG_AND    OP_INT_AND
-#define OP_LLONG_OR     OP_INT_OR
-#define OP_LLONG_XOR    OP_INT_XOR
-
-#define OP_ULLONG_IS_TRUE OP_LLONG_IS_TRUE
-#define OP_ULLONG_INVERT  OP_LLONG_INVERT
-#define OP_ULLONG_ADD OP_LLONG_ADD
-#define OP_ULLONG_SUB OP_LLONG_SUB
-#define OP_ULLONG_MUL OP_LLONG_MUL
-#define OP_ULLONG_LT OP_LLONG_LT
-#define OP_ULLONG_LE OP_LLONG_LE
-#define OP_ULLONG_EQ OP_LLONG_EQ
-#define OP_ULLONG_NE OP_LLONG_NE
-#define OP_ULLONG_GT OP_LLONG_GT
-#define OP_ULLONG_GE OP_LLONG_GE
-#define OP_ULLONG_AND OP_LLONG_AND
-#define OP_ULLONG_OR OP_LLONG_OR
-#define OP_ULLONG_XOR OP_LLONG_XOR
-
-/* ================================================== float.h ============ */
-
-/*** unary operations ***/
-
-#define OP_FLOAT_IS_TRUE(x,r)   OP_FLOAT_NE(x,0.0,r)
-#define OP_FLOAT_NEG(x,r)       r = -x
-#define OP_FLOAT_ABS(x,r)       r = fabs(x)
-
-/***  binary operations ***/
-
-#define OP_FLOAT_EQ(x,y,r)	  r = (x == y)
-#define OP_FLOAT_NE(x,y,r)	  r = (x != y)
-#define OP_FLOAT_LE(x,y,r)	  r = (x <= y)
-#define OP_FLOAT_GT(x,y,r)	  r = (x >  y)
-#define OP_FLOAT_LT(x,y,r)	  r = (x <  y)
-#define OP_FLOAT_GE(x,y,r)	  r = (x >= y)
-
-#define OP_FLOAT_CMP(x,y,r) \
-	r = ((x > y) - (x < y))
-
-/* addition, subtraction */
-
-#define OP_FLOAT_ADD(x,y,r)     r = x + y
-#define OP_FLOAT_SUB(x,y,r)     r = x - y
-#define OP_FLOAT_MUL(x,y,r)     r = x * y
-#define OP_FLOAT_TRUEDIV(x,y,r) r = x / y
-#define OP_FLOAT_POW(x,y,r)     r = pow(x, y) 
-
-/*** conversions ***/
-
-#define OP_CAST_FLOAT_TO_INT(x,r)       r = (long)(x)
-#define OP_CAST_FLOAT_TO_UINT(x,r)      r = (unsigned long)(x)
-#define OP_CAST_INT_TO_FLOAT(x,r)       r = (double)(x)
-#define OP_CAST_UINT_TO_FLOAT(x,r)      r = (double)(x)
-#define OP_CAST_LONGLONG_TO_FLOAT(x,r)  r = (double)(x)
-#define OP_CAST_BOOL_TO_FLOAT(x,r)      r = (double)(x)
-
-#ifdef HAVE_LONG_LONG
-#define OP_CAST_FLOAT_TO_LONGLONG(x,r)  r = (long long)(x)
-#endif
-
-/* ================================================== support.h ========== */
-
-#define RPyField(ptr, name)             NULL
-

Deleted: trunk/scipy/sandbox/mkufunc/test_func_hash.py
===================================================================
--- trunk/scipy/sandbox/mkufunc/test_func_hash.py	2008-07-01 00:32:12 UTC (rev 4507)
+++ trunk/scipy/sandbox/mkufunc/test_func_hash.py	2008-07-01 00:35:15 UTC (rev 4508)
@@ -1,47 +0,0 @@
-import unittest
-
-from mkufunc import func_hash
-
-
-class Tests(unittest.TestCase):
-    
-    def test_simple(self):
-        
-        def f(x):
-            return 2.5 * x * x + 4.7 * x
-        
-        self.assertEqual(func_hash(f),
-                         '5f12e97debf1d2cb9e0a2f92e045b1fb')
-        
-        
-    def test_extra(self):
-        
-        def f(x):
-            return 2.5 * x * x + 4.7 * x
-        
-        self.assertEqual(func_hash(f, salt=[(int, int), (float, float)]),
-                         'e637d9825ef20cb56d364041118ca72e')
-        
-    def test_const(self):
-        
-        def add_a(b):
-            return a + b   # a in globals
-        
-        self.assertEqual(func_hash(add_a),
-                         '9ff237f372bf233470ce940edd58f60d')
-        
-    def test_inner(self):
-
-        def foo(x):
-            inner1 = lambda t: t/3.0
-            def inner2(n):
-                return n + 3
-            return inner1(x) + inner2(int(x))
-
-        #func_hash(foo, verbose=1)
-        self.assertEqual(func_hash(foo),
-                         '814c113dfc77e7ebb52915dd3ce9c37a')
-
-
-if __name__ == '__main__':
-    unittest.main()

Deleted: trunk/scipy/sandbox/mkufunc/test_mkufunc.py
===================================================================
--- trunk/scipy/sandbox/mkufunc/test_mkufunc.py	2008-07-01 00:32:12 UTC (rev 4507)
+++ trunk/scipy/sandbox/mkufunc/test_mkufunc.py	2008-07-01 00:35:15 UTC (rev 4508)
@@ -1,270 +0,0 @@
-import math
-import unittest
-
-from numpy import array, arange, allclose
-
-from mkufunc import Cfunc, genufunc, mkufunc
-
-
-class Util:
-
-    def assertClose(self, x, y):
-        self.assert_(allclose(x, y), '%s != %s' % (x, y))
-            
-
-class Internal_Tests(unittest.TestCase, Util):
-    
-    def test_Cfunc(self):
-        def sqr(x):
-            return x * x
-        cf = Cfunc(sqr, [int, int], 42)
-        self.assertEqual(cf.nin, 1)
-        self.assertEqual(cf.nout, 1)
-        self.assertEqual(cf.cname, 'f42_pypy_g_sqr')
-
-    def test_genufunc(self):
-        def foo(x):
-            return x + 17
-        uf = genufunc(foo, [
-                (float, float),
-                (int, int),
-                ])
-        self.assertEqual(uf(4), 21)
-        x = array([1.1, 2.3])
-        y = uf(x)
-        self.assertClose(y, [18.1, 19.3])
-        self.assert_(str(y.dtype).startswith('float'))
-        
-        x = array([1, 4])
-        y = uf(x)
-        self.assertEqual(list(y), [18, 21])
-        self.assert_(str(y.dtype).startswith('int'))
-
-
-class Arg_Tests(unittest.TestCase, Util):
-    
-    def check_ufunc(self, f):
-        for arg in (array([0.0, 1.0, 2.5]),
-                    [0.0, 1.0, 2.5],
-                    (0.0, 1.0, 2.5)):
-            self.assertClose(f(arg), [0.0, 1.0, 6.25])
-            
-        self.assertEqual(f(3), 9)
-        self.assert_(f(-2.5) - 6.25 < 1E-10)
-
-    def test_direct(self):
-        @mkufunc
-        def f(x):
-            return x * x
-        self.check_ufunc(f)
-        
-    def test_noargs(self):
-        @mkufunc()
-        def f(x):
-            return x * x
-        self.check_ufunc(f)
-        
-    def test_varargs(self):
-        for arg in (float,
-                    [float],
-                    [(float, float)]):
-            @mkufunc(arg)
-            def f(x):
-                return x * x
-            self.check_ufunc(f)
-
-    def test_int(self):
-        @mkufunc(int)
-        def f(x):
-            return x * x
-        self.assertEqual(f(3), 9)
-        self.assert_(isinstance(f(42), int))
-        
-    def test_mixed(self):
-        @mkufunc([(int, float, int), float])
-        def f(n, x):
-            return n + x * x
-        
-        y = f(2, 3.9)            # Note that int(2 + 3.9 * 3.9) = 17
-        self.assertEqual(y, 17)
-        self.assert_(isinstance(y, int))
-        
-        y = f(2.0, 3.9)
-        self.assertClose(y, 17.21)
-        self.assert_(isinstance(y, float))
-        
-    def test_exceptions(self):
-        def f(x):
-            return x
-
-        self.assertRaises(TypeError, mkufunc, {})
-        self.assertRaises(TypeError, mkufunc([(float,)]), f)
-        self.assertRaises(TypeError, mkufunc([3*(float,)]), f)
-        self.assertRaises(TypeError, mkufunc([{}]), f)
-        self.assertRaises(TypeError, mkufunc([(int, {})]), f)
-        self.assertRaises(ValueError, mkufunc([]), f)
-        
-
-class Math_Tests(unittest.TestCase, Util):
-    
-    def assertFuncsEqual(self, uf, f):
-        x = 0.4376
-        a = uf(x)
-        b = f(x)
-        self.assertClose(a, b)
-        xx = arange(0.1, 0.9, 0.01)
-        a = uf(xx)
-        b = [f(x) for x in xx]
-        self.assertClose(a, b)
-        
-    def test_exp(self):
-        @mkufunc
-        def f(x): return math.exp(x)
-        self.assertFuncsEqual(f, math.exp)
-
-    def test_log(self):
-        @mkufunc
-        def f(x): return math.log(x)
-        self.assertFuncsEqual(f, math.log)
-
-    def test_sqrt(self):
-        @mkufunc
-        def f(x): return math.sqrt(x)
-        self.assertFuncsEqual(f, math.sqrt)
-        
-    def test_cos(self):
-        @mkufunc
-        def f(x): return math.cos(x)
-        self.assertFuncsEqual(f, math.cos)
-        
-    def test_sin(self):
-        @mkufunc
-        def f(x): return math.sin(x)
-        self.assertFuncsEqual(f, math.sin)
-        
-    def test_tan(self):
-        @mkufunc
-        def f(x): return math.tan(x)
-        self.assertFuncsEqual(f, math.tan)
-        
-    def test_acos(self):
-        @mkufunc
-        def f(x): return math.acos(x)
-        self.assertFuncsEqual(f, math.acos)
-
-    def test_asin(self):
-        @mkufunc
-        def f(x): return math.asin(x)
-        self.assertFuncsEqual(f, math.asin)
-        
-    def test_atan(self):
-        @mkufunc
-        def f(x): return math.atan(x)
-        self.assertFuncsEqual(f, math.atan)
-
-    def test_atan2(self):
-        @mkufunc
-        def f(x, y):
-            return math.atan2(x, y)
-
-        self.assertClose(f(4, 5), math.atan2(4, 5))
-        
-        xx = array([1.0, 3.0, -2.4,  3.1, -2.3])
-        yy = array([1.0, 2.0,  7.5, -8.7,  0.0])
-        a = f(xx, yy)
-        b = [math.atan2(x, y) for x, y in zip(xx, yy)]
-        self.assertClose(a, b)
-        
-    def test_arithmetic(self):
-        def f(x):
-            return (4 * x + 2) / (x * x - 7 * x + 1)
-        uf = mkufunc(f)
-        x = arange(0, 2, 0.1)
-        self.assertClose(uf(x), f(x))
-
-
-class FuncArg_Tests(unittest.TestCase, Util):
-    
-    def test_fargs0(self):
-        def f():
-            return 42
-        
-        uf = mkufunc(f)
-        self.assertEqual(uf(), 42)
-        self.assert_(type(uf()).__name__.startswith('float'))
-
-        uf = mkufunc(int)(f)
-        self.assertEqual(uf(), 42)
-        self.assert_(type(uf()).__name__.startswith('int'))
-
-
-class Control_Flow_Tests(unittest.TestCase):
-
-    def test_if(self):
-        @mkufunc(int)
-        def f(n):
-            if n < 4:
-                return n
-            else:
-                return n * n
-
-        self.assertEqual(f(3), 3)
-        self.assertEqual(f(4), 16)
-
-    def test_switch(self):
-        @mkufunc(int)
-        def f(n):
-            if n < 4:
-                return n
-            elif n == 4:
-                return 42
-            elif n == 5:
-                return 73
-            else:
-                return n * n
-
-        self.assertEqual(f(3), 3)
-        self.assertEqual(f(4), 42)
-        self.assertEqual(f(5), 73)
-        self.assertEqual(f(6), 36)
-
-    def test_loop(self):
-        @mkufunc(int)
-        def f(n):
-            res = 0
-            for i in xrange(n):
-                res += i*i
-            return res
-
-        self.assertEqual(f(3), 5)
-        self.assertEqual(f(95), 281295)
-
-
-class FreeVariable_Tests(unittest.TestCase, Util):
-
-    def test_const(self):
-        a = 13.6
-        @mkufunc
-        def f(x):
-            return a * x
-        
-        x = arange(0, 1, 0.1)
-        self.assertClose(f(x), a * x)
-
-    def test_const2(self):
-        from math import sin, pi, sqrt
-        @mkufunc
-        def sin_deg(angle):
-            return sin(angle / 180.0 * pi)
-        
-        self.assertClose(sin_deg([0, 30, 45, 60, 90, 180, 270, 360]),
-                         [0, 0.5, 1/sqrt(2), sqrt(3)/2, 1, 0, -1, 0])
-        
-
-class Misc_Tests(unittest.TestCase, Util):
-
-    pass
-
-
-if __name__ == '__main__':
-    unittest.main()

Deleted: trunk/scipy/sandbox/mkufunc/test_speed.py
===================================================================
--- trunk/scipy/sandbox/mkufunc/test_speed.py	2008-07-01 00:32:12 UTC (rev 4507)
+++ trunk/scipy/sandbox/mkufunc/test_speed.py	2008-07-01 00:35:15 UTC (rev 4508)
@@ -1,49 +0,0 @@
-#!/usr/bin/env python
-from math import sin, cos
-import time
-
-from numpy import arange, vectorize, allclose
-from scipy import weave
-
-from mkufunc import mkufunc
-
-
-def f(x):
-    return 4.2 * x * x + 3.7 * x + 1.5
-
-
-vfunc = vectorize(f)
-
-ufunc = mkufunc([(float, float)])(f)
-
-
-x = arange(0, 1000, 0.001)    #print "x =", x, x.dtype
-
-start_time = time.time()
-b_y = x.copy()
-weave.blitz("b_y[:] = 4.2 * x[:] * x[:] + 3.7 * x[:] + 1.5")
-b_time = time.time() - start_time
-print 'blitz: %.6f sec' % b_time
-
-start_time = time.time()
-n_y = f(x)
-n_time = time.time() - start_time
-print 'numpy: %.6f sec' % n_time
-
-start_time = time.time()
-v_y = vfunc(x)
-v_time = time.time() - start_time
-print 'vectorize: %.6f sec' % v_time
-
-start_time = time.time()
-u_y = ufunc(x)
-u_time = time.time() - start_time
-print 'mkufunc: %.6f sec' % u_time
-
-print "speedup over blitz:",     b_time/u_time
-print "speedup over numpy:",     n_time/u_time
-print "speedup over vectorize:", v_time/u_time
-
-assert allclose(b_y, n_y)
-assert allclose(v_y, n_y)
-assert allclose(u_y, n_y)



More information about the Scipy-svn mailing list