|
|
| 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 |
|
|
