94 lines
3.0 KiB
Python
94 lines
3.0 KiB
Python
|
|
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();
|
|
# Evaluate multiple times because the timer function
|
|
# has a significant overhead
|
|
g();g();g();g();g();g();g();g();g();g()
|
|
t2=clock()
|
|
t=min(t,(t2-t1)/10)
|
|
return t
|