def test_verify():
"""
Verify that scalar, vectorized, F77, weave implementations
give the same answer in a test problem.
"""
Lx = 10; Ly = 10; c = 1.0
def I(x, y):
return exp(-pow(x-Lx/2.0,2)/2.0 -pow(y-Ly/2.0,2)/2.0)
def f(x, y, t):
return sin(2*x) + y
def bc(x, y, t):
return sin(t)
# use string formulas instead so also weave can be tested:
# (need to transfer globals() so that vectorized versions work)
I = StringFunction('exp(-pow(x-Lx/2.0,2)/2.0 - pow(y-Ly/2.0,2)/2.0)',
independent_variables=('x', 'y'),
Lx=Lx, Ly=Ly, globals=globals())
f = StringFunction('sin(2*x) + y',
independent_variables=('x', 'y', 't'),
globals=globals())
bc = StringFunction('sin(t)',
independent_variables=('x', 'y', 't'),
globals=globals())
#nx = 15; ny = 10; tstop = 2
nx = 4; ny = 3; tstop = 16
verify_implementations(I, f, c, bc, Lx, Ly, nx, ny, tstop)
def benchmark(nx, tstop):
"""Initial Gaussian bell in the middle of the domain."""
Lx = 10
Ly = 10
c = 1.0
ny = nx
# our use of weave requires string formulas:
Is = StringFunction('exp(-pow(x-Lx/2.0,2)/2.0 -pow(y-Ly/2.0,2)/2.0)',
independent_variables=('x','y'),
Lx=Lx, Ly=Ly, globals=globals())
fs = StringFunction('0.0', independent_variables=('x', 'y', 't'),
globals=globals())
BCs = StringFunction('0.0', independent_variables=('x', 'y', 't'),
globals=globals())
def action(u, xv, yv, t):
#print t
pass
implementation = {}
cpu = []
for ic in 'f77', 'vec', 'scalar', 'weave':
for bc in 'f77', 'vec', 'scalar', 'weave':
for inner in 'f77', 'vec', 'scalar', 'weave':
implementation['ic'] = ic
implementation['inner'] = inner
implementation['bc'] = bc
# optimize StringFunction functions for the non-weave case:
# implementation:
if 'weave' in (ic, bc, inner) or 'f77' in (ic, bc, inner):
I = Is; f = fs; BC = BCs
else:
I = Is.__call__; f = fs.__call__; BC = BCs.__call__
t0 = time.clock()
dt, cpu_ic, cpu_inner, cpu_bc = \
solver(I, f, c, BC, Lx, Ly, nx, ny, 0, tstop,
user_action=None,
implementation=implementation,
verbose=False)
t1 = time.clock()
cpu_total = cpu_ic + cpu_inner + cpu_bc
overhead = (t1-t0)-cpu_total
cpu.append([implementation.copy(), cpu_total,
cpu_ic, cpu_inner, cpu_bc, overhead])
print t1-t0, implementation, 'overhead:', overhead
# normalize CPU-times:
cpu_min = min([abs(c) for i, c, c1, c2, c3, c4 in cpu])
print '\n\nMinimum CPU time:', cpu_min
print 'no of time steps:', int(tstop/dt)
print 'interior/boundary ratio:', int(nx*ny*1.0/max(nx,ny))
for impl, cpu, cpu_ic, cpu_inner, cpu_bc, overhead in cpu:
# normalized-CPU ic inner bc overhead
print "%8.2f" % (cpu/cpu_min),
print "%-10s %8.2f; " % (impl['ic'], cpu_ic),
print "%-10s %8.2f; " % (impl['inner'], cpu_inner),
print "%-10s %8.2f; " % (impl['bc'], cpu_bc),
print "%d%%" % (overhead/cpu*100)
def test_plot1(plot=1, version='scalar'):
"""
Initial Gaussian bell in the middle of the domain.
plot: 0 = no plot; 1 = on the screen, 2 = hardcopy too
"""
Lx = 10
Ly = 10
c = 1.0
def I2(x, y):
return exp(-(x-Lx/2.0)**2/2.0 -(y-Ly/2.0)**2/2.0)
def f(x, y, t):
return 0.0
def bc(x, y, t):
return 0.0
I2 = StringFunction('exp(-(x-Lx/2.0)**2/2.0 -(y-Ly/2.0)**2/2.0)',
independent_variables=('x', 'y'),
Lx=Lx, Ly=Ly, globals=globals())
f = StringFunction('0.0', independent_variables=('x', 'y', 't'),
globals=globals())
bc = StringFunction('0.0', independent_variables=('x', 'y', 't'),
globals=globals())
if plot:
g = Gnuplot.Gnuplot(persist=1)
g('set parametric')
g('set data style lines')
g('set hidden')
g('set contour base')
g('set zrange [-0.7:0.7]') # nice plot...
def action(u, xv, yv, t):
#print 'action, t=',t,'\nu=',u, '\nx=',x, '\ny=', y
if plot:
data = Gnuplot.GridData(u, xv[:,0], yv[0,:], binary=0)
g.splot(data)
g('set title "t=%g"' % t)
if plot == 2:
g.hardcopy(filename='tmp_%020f.ps' % t, enhanced=1, mode='eps',
color=0, fontname='Times-Roman', fontsize=14)
time.sleep(1)
time.sleep(0.2) # pause between frames
t0 = time.clock()
implementation = {'ic': version, 'inner': version, 'bc': version}
nx = 40; ny = 40; tstop = 700
solver(I2, f, c, bc, Lx, Ly, nx, ny, 0, tstop,
user_action=action, implementation=implementation)
t1 = time.clock()
cpu = t1 - t0
print 'CPU time: %s version =' % version, cpu
time.sleep(3)
def init_prms(m, b, L, k, beta, S0, dt, g, w_formula, N):
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--m', '--mass',
type=float, default=m)
parser.add_argument('--b', '--boxheight',
type=float, default=b)
parser.add_argument('--L', '--spring-length',
type=float, default=L)
parser.add_argument('--k', '--spring-stiffness',
type=float, default=k)
parser.add_argument('--beta', '--spring-damping',
type=float, default=beta)
parser.add_argument('--dt','--timestep',
type=float, default=dt)
parser.add_argument('--g', '--gravity',
type=float, default=g)
parser.add_argument('--S0', '--initial-position', type=str, default=str(S0)) #So that S0 can be an expression of other parameters (ex: m*g/k)
parser.add_argument('--w', type=str, default=w_formula)
parser.add_argument('--N', type=int, default=N)
args = parser.parse_args()
from scitools.StringFunction import StringFunction
w = StringFunction(args.w, independent_variables='t')
return args.m, args.b, args.L, args.k, args.beta, \
args.S0, args.dt, args.g, w, args.N
def parsedesc(string):
expr, rest = string.split(' is a function of ')
var_and_params = rest.split(' with parameter ')
func = StringFunction(expr, independent_variable=var_and_params[0])
if len(var_and_params) > 1:
parameters = eval("dict(%s)" % var_and_params[1])
func.set_parameters(**parameters)
return func
def test(argv=sys.argv):
f_formula = argv[1]
a = eval(argv[2])
b = eval(argv[3])
n = int(argv[4])
f = StringFunction(f_formula)
I = trapezoidal(f, a, b, n)
print 'Approximation of the integral: ', I
def equal(expr1, expr2, A, B, n=500):
failures = []
for t in range(1, n + 1) :
a = random.uniform(A, B)
b = random.uniform(A, B)
f = StringFunction(expr1, independent_variables=('a','b'))
s = StringFunction(expr2, independent_variables=('a','b'))
first = f(a, b)
second = s(a,b)
if first != second:
result = abs(first - second)
failures.append(result)
nFailures = float(len(failures))
percentage = (nFailures/n)*100
return n, nFailures, percentage
def test(argv=sys.argv):
try:
f_formula = argv[1]
a = eval(argv[2])
b = eval(argv[3])
n = int(argv[4])
except:
print "usage: %s 'f(x)' a b n" % sys.argv[0]
sys.exit(1)
f = StringFunction(f_formula)
I = trapezoidal(f, a, b, n)
print 'Approximation of the integral: ', I
def verify1():
g = Grid2D()
from scitools.StringFunction import StringFunction
expression = StringFunction('x + a*y',
independent_variables=('x', 'y'),
globals=globals(),
a=2)
f = g(expression)
print g, f
f = g.gridloop(expression)
print g, f
g = Grid2D(dx=0.05, dy=0.025)
f = g.vectorized_eval(expression)
plot_easyviz(g, f)
def deriv():
"""
On the fly, allows user input of symblic expression
prints derivative, returns derivative as string expression
"""
expression = raw_input('Enter an expression involving x: ')
from scitools.StringFunction import StringFunction
from sympy import diff, Symbol
x = Symbol('x')
f = StringFunction(expression)
df = diff(f, x)
print('The derivative of %s with respect to x is %s' % (expression, df))
return df
def verify1():
"""Basic test of the extension module."""
g = Grid2Deff(dx=0.5, dy=1)
f_exact = g(f1) # NumPy computation
expression1 = StringFunction('x + 2*y',
independent_variables=('x', 'y'),
globals=globals())
f = g.ext_gridloop1(f1)
print 'f computed by external gridloop1 function and f1:\n', f
if allclose(f, f_exact, atol=1.0E-10, rtol=1.0E-12):
print 'f is correct'
f = g.ext_gridloop2(f1)
print 'f computed by external gridloop2 function and f1:\n', f
if allclose(f, f_exact, atol=1.0E-10, rtol=1.0E-12):
print 'f is correct'
f = g.ext_gridloop1(expression1)
print 'f computed by external gridloop1 function and StringFunction:\n', f
if allclose(f, f_exact, atol=1.0E-10, rtol=1.0E-12):
print 'f is correct'
f = g.ext_gridloop2(expression1)
print 'f computed by external gridloop2 function and StringFunction:\n', f
if allclose(f, f_exact, atol=1.0E-10, rtol=1.0E-12):
print 'f is correct'
fast_func = expression1.__call__
f = g.ext_gridloop2(fast_func)
print 'f computed by external gridloop2 function and StringFunction.__call__:\n', f
if allclose(f, f_exact, atol=1.0E-10, rtol=1.0E-12):
print 'f is correct'
f = g(expression1)
print 'f computed by __call__ and StringFunction:\n', f
if allclose(f, f_exact, atol=1.0E-10, rtol=1.0E-12):
print 'f is correct'
# check printing:
print 'array seen from Python:'
g.dump(f)
if 'dump' in dir(ext_gridloop):
print 'array seen from Fortran (transposed, but right values):'
ext_gridloop.dump(f, g.xcoor, g.ycoor)
def main():
from scitools.StringFunction import StringFunction
import sys
try:
formula = sys.argv[1]
difftype = sys.argv[2]
difforder = sys.argv[3]
x = float(sys.argv[4])
except IndexError:
print 'Usage: Diff.py formula difftype difforder x'
print 'Example: Diff.py "sin(x)*exp(-x)" Central 4 3.14'
sys.exit(1)
classname = difftype + difforder
f = StringFunction(formula)
df = eval(classname)(f)
print df(x)
def integrate_function():
"""Integration function
Using scitools.StringFunction to do integration.
>>> integration.py 'sin(x)' 0 pi/2
integral of sin(x) on [0, 1.5708] with n=200: 1
"""
def midpoint_integration(f, a, b, n=100):
h = (b - a) / float(n)
I = 0
for i in range(n):
I += f(a + i * h + 0.5 * h)
return h * I
f_formula = sys.argv[1]
a = eval(sys.argv[2])
b = eval(sys.argv[3])
if len(sys.argv) >= 5:
n = int(sys.arvg[4])
else:
n = 200
from scitools.StringFunction import StringFunction
f = StringFunction(f_formula) # turn formula into f(x) func.
"""
>>> g = StringFunction('A*exp(-a*t)*sin(omega*x)',
independent_variable='t',
A=1, a=0.1, omega=pi, x=0.5)
>>> g.set_parameters(omega=0.1)
>>> g.set_parameters(omega=0.1, A=5, x=0)
>>> g(0)
0.0
>>> g(pi)
2.8382392288852166e-15
"""
I = midpoint_integration(f, a, b, n)
print("Integral of {:s} on [{:g}, {:g}] with n ={:d}: {:g}" \
.format(f_formula, a, b, n, I))
def __init__(self, input):
self.function = StringFunction(input)
self.input = input
K1 = dt * f(u[k], t[k])
K2 = dt * f(u[k] + 0.5 * K1, t[k] + dt2)
K3 = dt * f(u[k] + 0.5 * K2, t[k] + dt2)
K4 = dt * f(u[k] + K3, t[k] + dt)
u_new = u[k] + (1 / 6.0) * (K1 + 2 * K2 + 2 * K3 + K4)
return u_new
import sys
from scitools.StringFunction import StringFunction
try:
f_formula = sys.argv[1]
U0 = float(sys.argv[2])
dt = float(sys.argv[3])
T = float(sys.argv[4])
f = StringFunction(f_formula, independent_variables=('u', 't'))
except:
print("Usage: %s f U0 dt T" % sys.argv[0])
print("Optional 5° argument: numerical method")
sys.exit(1)
try:
method = eval(sys.argv[5])
except:
method = ForwardEuler #Default method
n = int(T / dt) + 1
times = np.linspace(
0, n * dt,
n + 1) #This way we respect the dt. The last point will be T' in [T;T+dt]
strfunc = "StringFunction('%s', " % func
if varpar.find('parameter') != -1:
var, par = varpar.split(' with parameter ')
var = [v.strip() for v in var.split(',')]
par = [p.strip() for p in par.split(',')]
strfunc += "independent_variables=('%s'), %s)" % \
("', '".join(var), ', '.join(par))
else:
var = [v.strip() for v in varpar.split(',')]
strfunc += "independent_variables=('%s'))" % \
("', '".join(var))
print strfunc # print what is passed to eval
return eval(strfunc)
infile = open('function_specifications.txt', 'r')
for specification in infile:
convert2strfunc(specification)
infile.close()
"""
Sample run:
python Exercise 6.21
StringFunction('sin(x)', independent_variables=('x'))
StringFunction('sin(a*y)', independent_variables=('y'), a=2)
StringFunction('sin(a*x-phi)', independent_variables=('x'), a=3, phi=-pi)
StringFunction('exp(-a*x)*cos(w*t)', independent_variables=('t'), a=1, w=pi, x=2)
StringFunction('b*ln(x)*tan(y/a)', independent_variables=('x', 'y'), a=3, b=0.5)
StringFunction('2*cos(p*x)*sin(q*y)', independent_variables=('x', 'y'), p=10, q=17)
StringFunction('sin(a*pi*x/8)*(2*pi)**-0.5*1/s*exp(-0.5*((t-m)/s)**2)', independent_variables=('x', 't'), a=0.5, s=10, m=0.2)
"""
def wrap2callable(f, **kwargs):
"""
Allow constants, string formulas, discrete data points,
user-defined functions and (callable) classes to be wrapped
in a new callable function. That is, all the mentioned data
structures can be used as a function, usually of space and/or
time.
(kwargs is used for string formulas)
>>> f1 = wrap2callable(2.0)
>>> f1(0.5)
2.0
>>> f2 = wrap2callable('1+2*x')
>>> f2(0.5)
2.0
>>> f3 = wrap2callable('1+2*t', independent_variable='t')
>>> f3(0.5)
2.0
>>> f4 = wrap2callable('a+b*t')
>>> f4(0.5)
Traceback (most recent call last):
...
NameError: name 'a' is not defined
>>> f4 = wrap2callable('a+b*t', independent_variable='t', a=1, b=2)
>>> f4(0.5)
2.0
>>> x = linspace(0, 1, 3); y=1+2*x
>>> f5 = wrap2callable((x,y))
>>> f5(0.5)
2.0
>>> def myfunc(x): return 1+2*x
>>> f6 = wrap2callable(myfunc)
>>> f6(0.5)
2.0
>>> f7 = wrap2callable(lambda x: 1+2*x)
>>> f7(0.5)
2.0
>>> class MyClass:
'Representation of a function f(x; a, b) =a + b*x'
def __init__(self, a=1, b=1):
self.a = a; self.b = b
def __call__(self, x):
return self.a + self.b*x
>>> myclass = MyClass(a=1, b=2)
>>> f8 = wrap2callable(myclass)
>>> f8(0.5)
2.0
>>> # 3D functions:
>>> f9 = wrap2callable('1+2*x+3*y+4*z', independent_variables=('x','y','z'))
>>> f9(0.5,1/3.,0.25)
4.0
>>> # discrete 3D data:
>>> y = linspace(0, 1, 3); z = linspace(-1, 0.5, 16)
>>> xv = reshape(x, (len(x),1,1))
>>> yv = reshape(y, (1,len(y),1))
>>> zv = reshape(z, (1,1,len(z)))
>>> def myfunc3(x,y,z): return 1+2*x+3*y+4*z
>>> values = myfunc3(xv, yv, zv)
>>> f10 = wrap2callable((x, y, z, values))
>>> f10(0.5, 1/3., 0.25)
4.0
One can also check what the object is wrapped as and do more
specific operations, e.g.,
>>> f9.__class__.__name__
'StringFunction'
>>> str(f9) # look at function formula
'1+2*x+3*y+4*z'
>>> f8.__class__.__name__
'MyClass'
>>> f8.a, f8.b # access MyClass-specific data
(1, 2)
Troubleshooting regarding string functions:
If you use a string formula with a numpy array, you typically get
error messages like::
TypeError: only rank-0 arrays can be converted to Python scalars.
You must then make the right import (numpy is recommended)::
from Numeric/numarray/numpy/scitools.numpytools import *
in the calling code and supply the keyword argument::
globals=globals()
to wrap2callable. See also the documentation of class StringFunction
for more information.
"""
if isinstance(f, str):
return StringFunction(f, **kwargs)
# this is a considerable optimization (up to a factor of 3),
# but then the additional info in the StringFunction instance
# is lost in the calling code:
# return StringFunction(f, **kwargs).__call__
elif isinstance(f, (float, int, complex)):
return WrapNo2Callable(f)
elif isinstance(f, (list, tuple)):
return WrapDiscreteData2Callable(f)
elif isinstance(f, collections.Callable):
return f
else:
raise TypeError('f of type %s is not callable' % type(f))
('a/b', '1/(b/a)'),\
('(a*b)**4', 'a**4*b**4'),\
('(a+b)**2', 'a**2 + 2*a*b + b**2'),\
('(a+b)*(a-b)', 'a**2 - b**2'),\
('log(a*b)', 'log(a) + log(b)'),\
('a*b', 'exp(log(a) + log(b))'),\
('1/(1/a + 1/b)', 'a*b/(a+b)'),\
('a*(sin(b)**2+cos(b)**2)', 'a'),\
('tan(a+b)', 'sin(a+b)/cos(a+b)'),\
('sin(a+b)', 'sin(a)*cos(b)+sin(b)*cos(a)')
)
print '%30s %30s %5s %5s %15s' % ('expression 1', 'expression 2', 'A', 'B',
'Success Rate')
A = 0
B = 1
for i in functions:
fn1 = StringFunction(i[0], independent_variables=('a', 'b'))
fn2 = StringFunction(i[1], independent_variables=('a', 'b'))
x = equal(fn1, fn2, A, B)
print '%30s %30s %5d %5d %15f' % (i[0], i[1], A, B, x)
print '%30s %30s %5s %5s %15s' % ('expression 1', 'expression 2', 'A', 'B',
'Success Rate')
A = 1E-7
B = 1E+7
for i in functions:
fn1 = StringFunction(i[0], independent_variables=('a', 'b'))
fn2 = StringFunction(i[1], independent_variables=('a', 'b'))
x = equal(fn1, fn2, A, B)
print '%30s %30s %5g %5g %15f' % (i[0], i[1], A, B, x)
k = float(value)
elif option in ('--beta', '--spring-damping'):
beta = float(value)
elif option in ('--S0', '--initial-position'):
S0 = float(value)
elif option in ('--dt', '--timestep'):
dt = float(value)
elif option in ('--g', '--gravity'):
g = float(value)
elif option in ('--w',):
w_formula = value # string
elif option == '--N':
N = int(value)
from scitools.StringFunction import StringFunction
w = StringFunction(w_formula, independent_variables='t')
return m, b, L, k, beta, S0, dt, g, w, N
def solve(m, k, beta, S0, dt, g, w, N,
user_action=lambda S, time, time_step_no: None):
"""Calculate N steps forward. Return list S."""
S = [0.0]*(N+1) # output list
gamma = beta*dt/2.0 # short form
t = 0
S[0] = S0
user_action(S, t, 0)
# special formula for first time step:
i = 0
S[i+1] = (1/(2.0*m))*(2*m*S[i] - dt**2*k*S[i] +
m*(w(t+dt) - 2*w(t) + w(t-dt)) + dt**2*m*g)
import sys
from scitools.StringFunction import StringFunction
parameters = {}
for prm in sys.argv[4:]:
key, value = prm.split('=')
parameters[key] = eval(value)
f = StringFunction(sys.argv[1], independent_valiable=sys.argv[2],
**parameters)
var = float(sys.argv[3])
print f
print f(var)
"""
The program accepts system arguments. It interperets the first
one as a function definition, the second one as the variable of
the function and the third one as where the function should be
evaluated. The rest of the arguments are also passed on to the
function.
"""
f = eval('StringFunction(sys.argv[1], ' + \
'independent_valiables=sys.argv[2], %s)' % \
(', '.join(sys.argv[4:]) ))
var = float(sys.argv[3])
print f(var)
"""
The second program does the same as the first one, only more directly
and compactly.
"""
def verify2(n=3):
"""
Test of some methods in class Grid2Deff that call up
some F77 routines for improving the efficiency of callbacks
to Python.
"""
if not 'gridloop_vec2' in dir(ext_gridloop):
raise ImportError, 'verify2 works only for F77 module'
dx = 1.0 / n
g = Grid2Deff(dx=dx, dy=dx)
from StringIO import StringIO
from scitools.numpyutils import arr
a_exact = arr(file_=StringIO("""
0. 0. 0. 0.
2.66666667 2.7775493 2.88706441 2.99386136
5.33333333 5.55373108 5.7632897 5.95170314
8. 8.3271947 8.6183698 8.84147098"""))
def _check():
if not allclose(a, a_exact):
print 'ERROR, a is wrong, correct a reads\n', a_exact
else:
print 'correct array'
a = g.ext_gridloop_vec1(myfuncf1)
print "g.ext_gridloop_vec1(myfuncf1): a=\n", a
_check()
a = g.ext_gridloop_vec2(myfuncf2)
print "g.ext_gridloop_vec2(myfuncf2): a=\n", a
_check()
# need f2py version > 2.42 (callback to class method):
a = g.ext_gridloop_vec3(g.myfuncf3)
print "g.ext_gridloop_vec3(g.myfuncf3): a=\n", a
_check()
a = g.ext_gridloop2_str('myfunc')
print "g.ext_gridloop_str('myfunc'): a=\n", a
_check()
a = g.ext_gridloop_noalloc('myfunc', a)
print "g.ext_gridloop_str_noalloc('myfunc'): a=\n", a
_check()
fstr = 'sin(x*y) + 8*x'
g.ext_gridloop2_fcb_compile(fstr)
a = g.ext_gridloop2_fcb()
print "g.gridloop2_fcb: a=\n", a
_check()
import callback
print 'contents of callback module:', dir(callback)
fstr = StringFunction('sin(x*y) + 8*x')
g.ext_gridloop2_fcb_ptr_compile(fstr)
a = g.ext_gridloop2_fcb_ptr()
print "g.gridloop2_fcb_ptr: a=\n", a
_check()
import callback
print 'fcb callback module:', dir(callback), dir(callback.fcb)
g.ext_gridloop2_compile(fstr)
a = g.ext_gridloop2_v2()
print "g.gridloop2_v2: a=\n", a
_check()
a = g.ext_gridloop2_weave(fstr)
print "g.gridloop2_weave: a=\n", a
_check()
g.gridloop_psyco_init(g.gridloop)
a = g.gridloop_psyco(fstr)
print "g.gridloop_psyco(str): a=\n", a
_check()
a = g.gridloop_psyco(myfunc)
print "g.gridloop_psyco(func): a=\n", a
_check()
g.ext_gridloop1_instant(fstr)
g.gridloop1_instant(a, g.nx, g.ny, g.xcoor, g.ycoor)
print "g.gridloop1_instant: a=\n", a
#------------------------------------------------------------------------------#
# UI Management #
#------------------------------------------------------------------------------#
# Clear the terminal for readability
print("\033c" + "*************************************************")
print("CS 101 James Scholar Project By Kenneth Tochihara")
print("*************************************************")
print("\nCtrl + C to exit at anytime. ")
# Infinite loop until KeyboardInterrupt
while True:
try:
# Taking in the values
f = StringFunction(input("f(u, t) = "),
independent_variables=('u', 't'))
u0 = float(input("u0 = ")) #initial condition
dt = float(input("dt = ")) #time step
T = float(input("T = ")) #Final time of simulation
type = str(input("Solve Method: "))
#Initializing the u array, arrU and time array, arrT
arrU = []
currentT = 0
arrT = [currentT]
while (currentT < T) or (np.isclose(currentT, T)):
currentT += dt
arrT.append(currentT)
#------------------------------------------------------------------------------#
# Deciding which method to use #
""" TODO Exercise 3.13. Extend a program from Ch. 3.2.1. How can you modify the add_cml.py program from the end of Chap- ter 3.1.2 such that it accepts input like sqrt(2) and sin(1.2)? """ import math import sys from scitools.StringFunction import StringFunction i1 = StringFunction(sys.argv[1]) i2 = StringFunction(sys.argv[2]) print i1, i2 #print '%s + %s becomes %s\nwith value %s' % \ # (type(i1), type(i2), type(r), r)
# Exercise 5.32
# Author: Noah Waterfield Price
from numpy import *
import matplotlib.pyplot as plt
import sys
from scitools.StringFunction import StringFunction
f = StringFunction(sys.argv[1])
f.vectorize(globals())
if len(sys.argv) == 5:
n = sys.argv[4]
else:
n = 501
x = linspace(eval(sys.argv[2]), eval(sys.argv[3]), n)
plt.plot(x, f(x))
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend(['f(x) = %s' % sys.argv[1]])
plt.show()
raw_input()
def __init__(self):
# Set default parameter values
self.alpha = 1.
self.R = StringFunction('1.0', independent_variable='t')
self.U0 = 0.01
self.T = 4.
try:
k = float(sys.argv[1])
m = float(sys.argv[2])
x0 = float(sys.argv[3])
force_formula = sys.argv[4]
tstart = float(sys.argv[5])
tstop = float(sys.argv[6])
dt = float(sys.argv[7])
except IndexError, e:
print e, '\n', usage
sys.exit(1)
if force_formula != '0':
from scitools.StringFunction import StringFunction
F = StringFunction(formula)
else:
F = None
print F
t = tstart
x = [x0, x0]
while t <= tstop:
t += dt
if F is not None:
try:
F_value = F(t)
except:
raise ValueError('Could not evaluate %s for t=%g' \
% (force_formula, t))
import sys
usage = '%s f-formula a b [epsilon]' % sys.argv[0]
try:
f_formula = sys.argv[1]
a = float(sys.argv[2])
b = float(sys.argv[3])
except IndexError:
print usage
sys.exit(1)
try: # is epsilon given on the command-line?
epsilon = float(sys.argv[4])
except IndexError:
epsilon = 1E-6 # default value
from scitools.StringFunction import StringFunction
from math import * # might be needed for f_formula
f = StringFunction(f_formula)
from bisection import bisection
root, iter = bisection(f, a, b, epsilon)
if root == None:
print 'The interval [%g, %g] does not contain a root' % (a, b)
sys.exit(1)
print 'Found root %g\nof %s = 0 in [%g, %g] in %d iterations' % \
(root, f_formula, a, b, iter)
def timing2(n=2000, best_time=1.0):
"""Time different implementations of the extension module."""
print 'Grid2Deff.timing2: reference CPU time = %g' % best_time
dx = 1.0 / n
g = Grid2Deff(dx=dx, dy=dx)
# here we use straight NumPy sin in a scalar context:
def myfunc1(x, y):
return sin(x * y) + 8 * x
def myfunc2(x, y):
return math.sin(x * y) + 8 * x
expression1 = StringFunction('sin(x*y) + 8*x',
independent_variables=('x', 'y'),
globals=globals())
expression1_f = expression1.__call__ # for efficiency and F77 callback
expression2 = StringFunction('math.sin(x*y) + 8*x',
independent_variables=('x', 'y'),
globals=globals())
expression2_f = expression2.__call__ # for efficiency and F77 callback
from scitools.misc import timer
from scitools.EfficiencyTable import EfficiencyTable
e = EfficiencyTable('Grid2Deff tests, %dx%d grid' % (n, n), best_time)
t0a = timer(g.gridloop, (myfunc1, ), repetitions=1)
e.add('g.gridloop, myfunc1', t0a)
t0b = timer(g.gridloop, (myfunc2, ), repetitions=1)
e.add('g.gridloop, myfunc2', t0b)
t0c = timer(g.__call__, (myfunc1, ), repetitions=1)
e.add('g.__call__, myfunc1', t0c)
t0d = timer(g.__call__, (expression1_f, ), repetitions=1)
e.add('g.__call__, expression1_f', t0d)
t0e = timer(g.gridloop_itemset, (myfunc2, ), repetitions=1)
e.add('g.gridloop_itemset, myfunc2', t0e)
t1a = timer(g.ext_gridloop1, (myfunc1, ), repetitions=1)
e.add('g.ext_gridloop1, myfunc1', t1a)
t1b = timer(g.ext_gridloop1, (myfunc2, ), repetitions=1)
e.add('g.ext_gridloop1, myfunc2', t1b)
t2a = timer(g.ext_gridloop2, (myfunc1, ), repetitions=1)
e.add('g.ext_gridloop2, myfunc1', t2a)
t2b = timer(g.ext_gridloop2, (myfunc2, ), repetitions=1)
e.add('g.ext_gridloop2, myfunc2', t2b)
t3a = timer(g.ext_gridloop2, (expression1_f, ), repetitions=1)
e.add('g.ext_gridloop2, expression1_f', t3a)
t3b = timer(g.ext_gridloop2, (expression2_f, ), repetitions=1)
e.add('g.ext_gridloop2, expression2_f', t3b)
nrep = 20
# try the improved functions (works only for the F77 module):
if 'gridloop_vec2' in dir(ext_gridloop):
t4 = timer(g.ext_gridloop_vec2, (myfuncf2, ), repetitions=nrep)
e.add('g.ext_gridloop_vec2, myfuncf2', t4)
if 'gridloop2_str' in dir(ext_gridloop):
t5 = timer(g.ext_gridloop2_str, ('myfunc', ), repetitions=nrep)
e.add('g.ext_gridloop2_str, myfunc', t5)
# try the version without allocation (first, make an a array):
a = g.ext_gridloop2(myfunc1) # a has now Fortran storage
t5b = timer(g.ext_gridloop_noalloc, ('myfunc', a), repetitions=nrep)
e.add('g.ext_gridloop_noalloc, myfunc', t5b)
# try 'inline' F77 compiled callback too:
# (give F77 source for core of callback function as argument)
g.ext_gridloop2_fcb_compile(str(expression1))
t6 = timer(g.ext_gridloop2_fcb, (), repetitions=nrep)
e.add('g.ext_gridloop2_fcb(%s)' % repr(str(expression1)), t6)
g.ext_gridloop2_fcb_ptr_compile(expression1)
t6b = timer(g.ext_gridloop2_fcb_ptr, (), repetitions=nrep)
e.add('g.ext_gridloop2_fcb_ptr(%s)' % repr(expression1), t6b)
g.ext_gridloop2_compile(str(expression1))
t7 = timer(g.ext_gridloop2_v2, (), repetitions=nrep)
e.add('g.ext_gridloop2_v2(%s)' % repr(str(expression1)), t7)
# weave version:
t8 = timer(g.ext_gridloop2_weave, (str(expression1), ), repetitions=nrep)
e.add('g.ext_gridloop2_weave(%s)' % repr(str(expression1)), t8)
# psyco:
g.gridloop_psyco_init(g.gridloop)
if g.gridloop_psyco != g.gridloop: # has psyco
t9a = timer(g.gridloop_psyco, (myfunc2, ), repetitions=1)
e.add('g.gridloop_psyco, myfunc2', t9a)
t9b = timer(g.gridloop_psyco, (expression2_f, ), repetitions=1)
e.add('g.gridloop_psyco, expression2_f', t9b)
g.gridloop_psyco_init(g.gridloop_itemset)
if g.gridloop_psyco != g.gridloop_itemset: # has psyco
t9a = timer(g.gridloop_psyco, (myfunc2, ), repetitions=1)
e.add('g.gridloop_psyco (itemset), myfunc2', t9a)
t9b = timer(g.gridloop_psyco, (expression2_f, ), repetitions=1)
e.add('g.gridloop_psyco (itemset), expression2_f', t9b)
# instant:
g.ext_gridloop1_instant(str(expression1))
if g.gridloop1_instant is not None:
a = zeros((self.nx, self.ny))
t10 = timer(g.gridloop1_instant, (a, self.nx, g.ny, g.xcoor, g.ycoor),
repetitions=nrep)
e.add('g.gridloop1_instant', t10)
print '\n\n\n\nrun from directory', os.getcwd()
print e
if dfdx is not None:
print '%15f' % (dfdx(x))
else:
print ''
from scitools.std import *
f = ['x**2', 'sin(pi*x)**6', 'tanh(10*x)']
df = ['2*x', '6*pi*sin(pi*x)**5*cos(pi*x)', '10*(1-tanh(10*x)**2)']
hlist = [1E-1, 1E-3, 1E-5, 1E-7]
from scitools.StringFunction import StringFunction
x = [0, 0.25]
for a in range(2):
for b in range(3):
print 'x = %.2f, f = %s' % (x[a], f[b])
table(StringFunction(f[b]), x[a], hlist, \
StringFunction(df[b]))
print ''
x = linspace(-1, 1, 500)
for a in f:
figure()
plot(x, vectorize(StringFunction(a))(x), title='%s' % a)
raw_input('Press Enter to quit:')
'''
python Derivative_comparisons.py
x = 0.00, f = x**2
h Derivative Central True
0.1 0.1 0 0.000000
0.001 0.001 0 0.000000
1e-05 1e-05 0 0.000000
def toStringFunction(text):
return StringFunction(text, independent_variable='t')
