| |
|
| | def monitor(f, input='print', output='print'): |
| | """ |
| | Returns a wrapped copy of *f* that monitors evaluation by calling |
| | *input* with every input (*args*, *kwargs*) passed to *f* and |
| | *output* with every value returned from *f*. The default action |
| | (specify using the special string value ``'print'``) is to print |
| | inputs and outputs to stdout, along with the total evaluation |
| | count:: |
| | |
| | >>> from mpmath import * |
| | >>> mp.dps = 5; mp.pretty = False |
| | >>> diff(monitor(exp), 1) # diff will eval f(x-h) and f(x+h) |
| | in 0 (mpf('0.99999999906867742538452148'),) {} |
| | out 0 mpf('2.7182818259274480055282064') |
| | in 1 (mpf('1.0000000009313225746154785'),) {} |
| | out 1 mpf('2.7182818309906424675501024') |
| | mpf('2.7182808') |
| | |
| | To disable either the input or the output handler, you may |
| | pass *None* as argument. |
| | |
| | Custom input and output handlers may be used e.g. to store |
| | results for later analysis:: |
| | |
| | >>> mp.dps = 15 |
| | >>> input = [] |
| | >>> output = [] |
| | >>> findroot(monitor(sin, input.append, output.append), 3.0) |
| | mpf('3.1415926535897932') |
| | >>> len(input) # Count number of evaluations |
| | 9 |
| | >>> print(input[3]); print(output[3]) |
| | ((mpf('3.1415076583334066'),), {}) |
| | 8.49952562843408e-5 |
| | >>> print(input[4]); print(output[4]) |
| | ((mpf('3.1415928201669122'),), {}) |
| | -1.66577118985331e-7 |
| | |
| | """ |
| | if not input: |
| | input = lambda v: None |
| | elif input == 'print': |
| | incount = [0] |
| | def input(value): |
| | args, kwargs = value |
| | print("in %s %r %r" % (incount[0], args, kwargs)) |
| | incount[0] += 1 |
| | if not output: |
| | output = lambda v: None |
| | elif output == 'print': |
| | outcount = [0] |
| | def output(value): |
| | print("out %s %r" % (outcount[0], value)) |
| | outcount[0] += 1 |
| | def f_monitored(*args, **kwargs): |
| | input((args, kwargs)) |
| | v = f(*args, **kwargs) |
| | output(v) |
| | return v |
| | return f_monitored |
| |
|
| | def timing(f, *args, **kwargs): |
| | """ |
| | Returns time elapsed for evaluating ``f()``. Optionally arguments |
| | may be passed to time the execution of ``f(*args, **kwargs)``. |
| | |
| | If the first call is very quick, ``f`` is called |
| | repeatedly and the best time is returned. |
| | """ |
| | once = kwargs.get('once') |
| | if 'once' in kwargs: |
| | del kwargs['once'] |
| | if args or kwargs: |
| | if len(args) == 1 and not kwargs: |
| | arg = args[0] |
| | g = lambda: f(arg) |
| | else: |
| | g = lambda: f(*args, **kwargs) |
| | else: |
| | g = f |
| | from timeit import default_timer as clock |
| | t1=clock(); v=g(); t2=clock(); t=t2-t1 |
| | if t > 0.05 or once: |
| | return t |
| | for i in range(3): |
| | t1=clock(); |
| | |
| | |
| | g();g();g();g();g();g();g();g();g();g() |
| | t2=clock() |
| | t=min(t,(t2-t1)/10) |
| | return t |
| |
|
