def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--I', type=float, default=1.0)
parser.add_argument('--V', type=float, default=0.0)
parser.add_argument('--m', type=float, default=1.0)
parser.add_argument('--b', type=float, default=0.0)
parser.add_argument('--s', type=str, default='u')
parser.add_argument('--F', type=str, default='0')
parser.add_argument('--dt', type=float, default=0.05)
parser.add_argument('--T', type=float, default=10)
parser.add_argument('--window_width',
type=float,
default=30.,
help='Number of periods in a window')
parser.add_argument('--damping', type=str, default='linear')
parser.add_argument('--savefig', action='store_true')
# Hack to allow --SCITOOLS options
# (scitools.std reads this argument at import)
parser.add_argument('--SCITOOLS_easyviz_backend', default='matplotlib')
a = parser.parse_args()
from scitools.std import StringFunction
s = StringFunction(a.s, independent_variable='u')
F = StringFunction(a.F, independent_variable='t')
I, V, m, b, dt, T, window_width, savefig, damping = \
a.I, a.V, a.m, a.b, a.dt, a.T, a.window_width, a.savefig, \
a.damping
filename = 'vibration_sim.dat'
u_min, u_max = solve_and_store(filename, I, V, m, b, s, F, dt, T, damping)
read_and_plot(filename, u_min, u_max)
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--I', type=float, default=1.0)
parser.add_argument('--V', type=float, default=0.0)
parser.add_argument('--m', type=float, default=1.0)
parser.add_argument('--c', type=float, default=0.0)
parser.add_argument('--s', type=str, default='u')
parser.add_argument('--F', type=str, default='0')
parser.add_argument('--dt', type=float, default=0.05)
parser.add_argument('--T', type=float, default=140)
parser.add_argument('--window_width', type=float, default=30)
parser.add_argument('--savefig', action='store_true')
# Hack to allow --SCITOOLS options (read when importing scitools.std)
parser.add_argument('--SCITOOLS_easyviz_backend', default='matplotlib')
a = parser.parse_args()
from scitools.std import StringFunction
s = StringFunction(a.s, independent_variable='u')
F = StringFunction(a.F, independent_variable='t')
I, V, m, c, dt, T, window_width, savefig = \
a.I, a.V, a.m, a.c, a.dt, a.T, a.window_width, a.savefig
u, t = solver(I, V, m, c, s, F, dt, T)
num_periods = empirical_freq_and_amplitude(u, t)
if num_periods <= 40:
figure() # new matplotlib figure
visualize(u, t)
else:
visualize_front(u, t, window_width, savefig) # scitools
visualize_front_ascii(u, t)
show()
def main():
# Note: the reading of parameter values would better be done
# from each relevant class, i.e. class Problem should read I, V,
# etc., while class Solver should read dt and T, and so on.
# Consult, e.g., Langtangen: "A Primer on Scientific Programming",
# App E.
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--I', type=float, default=1.0)
parser.add_argument('--V', type=float, default=0.0)
parser.add_argument('--m', type=float, default=1.0)
parser.add_argument('--b', type=float, default=0.0)
parser.add_argument('--s', type=str, default=None)
parser.add_argument('--F', type=str, default='0')
parser.add_argument('--dt', type=float, default=0.05)
parser.add_argument('--T', type=float, default=20)
parser.add_argument('--window_width',
type=float,
default=30.,
help='Number of periods in a window')
parser.add_argument('--damping', type=str, default='linear')
parser.add_argument('--savefig', action='store_true')
# Hack to allow --SCITOOLS options
# (scitools.std reads this argument at import)
parser.add_argument('--SCITOOLS_easyviz_backend', default='matplotlib')
a = parser.parse_args()
from scitools.std import StringFunction
if a.s != None:
s = StringFunction(a.s, independent_variable='u')
else:
s = None
F = StringFunction(a.F, independent_variable='t')
if a.F == '0': # free vibrations
problem = Free_vibrations(s=s,
I=a.I,
V=a.V,
m=a.m,
b=a.b,
damping=a.damping)
else: # forced vibrations
problem = Forced_vibrations(lambda t: np.sin(t),
s=s,
I=a.I,
V=a.V,
m=a.m,
b=a.b,
damping=a.damping)
solver = Solver(dt=a.dt, T=a.T)
solver.solve(problem)
visualizer = Visualizer(problem, solver, a.window_width, a.savefig)
visualizer.visualize()
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--I', type=float, default=1.0)
parser.add_argument('--V', type=float, default=0.0)
parser.add_argument('--m', type=float, default=1.0)
parser.add_argument('--b', type=float, default=0.0)
parser.add_argument('--s', type=str, default='4*pi**2*u')
parser.add_argument('--F', type=str, default='0')
parser.add_argument('--dt', type=float, default=0.05)
parser.add_argument('--T', type=float, default=20)
parser.add_argument('--window_width',
type=float,
default=30.,
help='Number of periods in a window')
parser.add_argument('--damping', type=str, default='linear')
parser.add_argument('--savefig', action='store_true')
# Hack to allow --SCITOOLS options
# (scitools.std reads this argument at import)
parser.add_argument('--SCITOOLS_easyviz_backend', default='matplotlib')
a = parser.parse_args()
from scitools.std import StringFunction
s = StringFunction(a.s, independent_variable='u')
F = StringFunction(a.F, independent_variable='t')
I, V, m, b, dt, T, window_width, savefig, damping = \
a.I, a.V, a.m, a.b, a.dt, a.T, a.window_width, a.savefig, \
a.damping
# compute u by both methods and then visualize the difference
u, t = solver2(I, V, m, b, s, F, dt, T, damping)
u_bw, _ = solver_bwdamping(I, V, m, b, s, F, dt, T, damping)
u_diff = u - u_bw
num_periods = plot_empirical_freq_and_amplitude(u_diff, t)
if num_periods <= 40:
plt.figure()
legends = [
'1st-2nd order method', '2nd order method', '1st order method'
]
visualize([(u_diff, t), (u, t), (u_bw, t)], legends)
else:
visualize_front(u_diff, t, window_width, savefig)
#visualize_front_ascii(u_diff, t)
plt.show()
def __init__(self,
m=1,
b=0,
s=lambda u: (2 * np.pi)**2 * u,
F=lambda t: 0,
I=1,
V=0,
damping='linear'):
if isinstance(s, str):
# Turn string formula into Python function
# (send globals() such that pi, sin, cos, etc from
# numpy can be used in the string expression)
s = StringFunction(s, globals=globals())
if isinstance(F, str):
F = StringFunction(F, globals=globals())
self.m, self.b, self.s, self.F = float(m), b, s, F
self.I, self.V = I, V
self.damping = damping
def get_input():
"""Get f, a, b, eps from the command line."""
from scitools.std import StringFunction
try:
f = StringFunction(sys.argv[1])
a = float(sys.argv[2])
b = float(sys.argv[3])
eps = float(sys.argv[4])
except IndexError:
print 'Usage %s: f a b eps' % sys.argv[0]
sys.exit(1)
return f, a, b, eps
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--I', type=float, default=1.0)
parser.add_argument('--V', type=float, default=0.0)
parser.add_argument('--m', type=float, default=1.0)
parser.add_argument('--b', type=float, default=0.0)
parser.add_argument('--s', type=str, default='u')
parser.add_argument('--F', type=str, default='0')
parser.add_argument('--dt', type=float, default=0.05)
#parser.add_argument('--T', type=float, default=10)
parser.add_argument('--T', type=float, default=20)
parser.add_argument('--window_width',
type=float,
default=30.,
help='Number of periods in a window')
parser.add_argument('--damping', type=str, default='linear')
parser.add_argument('--savefig', action='store_true')
# Hack to allow --SCITOOLS options (scitools.std reads this argument
# at import)
parser.add_argument('--SCITOOLS_easyviz_backend', default='matplotlib')
a = parser.parse_args()
from scitools.std import StringFunction
s = StringFunction(a.s, independent_variable='u')
F = StringFunction(a.F, independent_variable='t')
I, V, m, b, dt, T, window_width, savefig, damping = \
a.I, a.V, a.m, a.b, a.dt, a.T, a.window_width, a.savefig, \
a.damping
u, t = solver(I, V, m, b, s, F, dt, T, damping)
num_periods = plot_empirical_freq_and_amplitude(u, t)
if num_periods <= 40:
plt.figure()
visualize(u, t)
else:
visualize_front(u, t, window_width, savefig)
visualize_front_ascii(u, t)
plt.show()
def table(f, X, h=1E-5): #supply the function as a string
x = sympy.Symbol('x')
df_expr = sympy.diff(f)
df_true = sympy.lambdify([x], df_expr)
f_func = StringFunction(f)
df_appr = Central(f_func)
print '%18s %18s %18s %18s' % ('x', 'df(x) approx', 'df(x) actual',
'error')
print '-' * 75
for x in X:
er = abs(df_appr(x) - df_true(x))
print '%18.14f %18.14f %18.14f %18.14f' % (x, df_appr(x), df_true(x),
er)
def main():
"""
Read f-formula, a, b, n from the command line.
Print the result of integrate(f, a, b, n).
"""
try:
f_formula = sys.argv[1]
a = eval(sys.argv[2])
b = eval(sys.argv[3])
n = int(sys.argv[4])
except IndexError:
print 'Usage: %s f-formula a b n' % sys.argv[0]
sys.exit(1)
from scitools.std import StringFunction
f = StringFunction(f_formula)
I = integrate(f, a, b, n)
print I
def toStringFunction(text):
return StringFunction(text, independent_variable='t')
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.
import ODESolver, sys
import numpy as np, matplotlib.pyplot as plt
from scitools.std import StringFunction
try:
f = StringFunction(sys.argv[1])
U0 = float(sys.argv[2])
dt = float(sys.argv[3])
T = float(sys.argv[4])
except ValueError:
print 'cml should contain str(f), float(U0), float(dt) and float(T)'
sys.exit(1)
except IndexError:
print 'cml should contain 4 arguments'
sys.exit(1)
def f(u, t):
return f
n = int(T / dt + 1)
FE = ODESolver.ForwardEuler(f)
FE.set_initial_condition(U0)
u, t = FE.solve(time_points=np.linspace(0, T, n))
plt.plot(t, u)
plt.show()
#!/usr/bin/env python
import numpy as np
from scitools.std import StringFunction
def Explicit_Euler(f, u0, T, n):
dt = T/float(n)
t = np.linspace(0, T, n+1)
u = np.zeros(n+1)
u[0] = u0
for k in range(n):
u[k+1] = u[k] + dt*f(u[k])
return u, t
if __name__ == '__main__':
try:
f_formula = sys.argv[1]
n = int(sys.argv[2])
T = eval(sys.argv[3])
u0 = eval(sys.argv[4])
except:
print "usage:", sys.argv[0], "'f(u)' n T u0 "; sys.exit(1)
f = StringFunction(f_formula, independent_variables='u')
u, t = Explicit_Euler(f, u0, T, n)
plot(t, u)
def __call__(self, parser, namespace, values, option_string=None):
setattr(namespace, self.dest,
StringFunction(values, independent_variable='p'))
def toStringFunction4s0(text):
from scitools.std import StringFunction
return StringFunction(text, independent_variable='p')
help='initial velocity')
parser.add_argument('--s0',
'--initial_position',
default='0.0',
help='initial position')
parser.add_argument('--a',
'--acceleration',
default='1.0',
help='acceleration')
parser.add_argument('--t', '--time', default='1.0', help='time')
example = "--s0 'exp(-1.5) + 10*(1-p**2)' --v0 pi/4"
#args = parser.parse_args(example.split())
args = parser.parse_args()
# Conversion
from math import *
from scitools.std import StringFunction
s0 = StringFunction(args.s0, independent_variable='p')
v0 = eval(args.v0)
a = eval(args.a)
t = eval(args.t)
p = 0.5
s = s0(p) + v0 * t + 0.5 * a * t**2
print """
An object, starting at s=%s=%g (p=%g) at t=0 with initial
velocity %s m/s, and subject to a constant
acceleration %g m/s**2, is found at the
location s=%g m after %s seconds.
""" % (str(s0), s0(p), p, v0, a, s, t)
import sys, sympy
from scitools.std import StringFunction
f = StringFunction(sys.argv[1], independent_variable='x')
x = float(sys.argv[2])
def numerical_derivative(f, x, h=1E-5):
return (f(x + h) - f(x - h)) / (2 * h)
print 'Numerical derivative:', numerical_derivative(f, x)
# Import all sin, cos, exp, ... functions from sympy such that
# we can build a sympy expression out of str(f)
from sympy import *
x_value = x
# Let x be a math symbol (not a float)
x = sympy.symbols('x')
# Turn the string formula in f (StringFunction) into
# a sympy expression
print "'%s'" % str(f)
formula = eval(str(f)) # ex: eval('exp(x)*sin(x)')
# Alternative: formula = eval(sys.argv[1])
# Differentiate formula wrt symbol x
dfdx = diff(formula, x)
# Substitute symbol x by x_value
dfdx_value = dfdx.subs(x, x_value)
