def comparison_plot(f, u, Omega, filename='tmp.pdf',
plot_title='', ymin=None, ymax=None,
u_legend='approximation'):
"""Compare f(x) and u(x) for x in Omega in a plot."""
x = sm.Symbol('x')
print 'f:', f
f = sm.lambdify([x], f, modules="numpy")
u = sm.lambdify([x], u, modules="numpy")
if len(Omega) != 2:
raise ValueError('Omega=%s must be an interval (2-list)' % str(Omega))
# When doing symbolics, Omega can easily contain symbolic expressions,
# assume .evalf() will work in that case to obtain numerical
# expressions, which then must be converted to float before calling
# linspace below
if not isinstance(Omega[0], (int,float)):
Omega[0] = float(Omega[0].evalf())
if not isinstance(Omega[1], (int,float)):
Omega[1] = float(Omega[1].evalf())
resolution = 401 # no of points in plot
xcoor = linspace(Omega[0], Omega[1], resolution)
# Vectorized functions expressions does not work with
# lambdify'ed functions without the modules="numpy"
exact = f(xcoor)
approx = u(xcoor)
plot(xcoor, approx, '-')
hold('on')
plot(xcoor, exact, '-')
legend([u_legend, 'exact'])
title(plot_title)
xlabel('x')
if ymin is not None and ymax is not None:
axis([xcoor[0], xcoor[-1], ymin, ymax])
savefig(filename)
def calculate_path(self):
f, g, t, dt, s = (self.f, self.g, self.t, self.delta, self.s)
der_f, der_g = [diff(coord, t) for coord in f, g]
tanf, tang = [lambdify((t, s), coord + der * s, numpy) for coord, der in ((f, der_f), (g, der_g))]
coords = lambdify(t, (f, g), numpy)
print der_f.subs(t, t + dt)
get_control_param = lambdify(t, (g - g.subs(t, t + dt)) / (der_g.subs(t, t + dt) - der_g), numpy)
def control_coords(time):
control_param = get_control_param(time)
return (tangent(time, control_param) for tangent in (tanf, tang))
x_o, y_o = coords(self.min)
path = "M%f, %f" % (x_o, y_o)
def append_curve(path, point, control_point):
return "%s Q%f, %f %f, %f" % (path, point.x, point.y, control_point.x, control_point.y)
for time in numpy.arange(self.min + self.delta, self.max - self.delta, self.delta):
x, y = coords(time)
x_c, y_c = control_coords(time)
path = append_curve(path, Point(x, y), Point(x_c, y_c))
x_f, y_f = coords(self.max)
path = "%s T%f, %f" % (path, x_f, y_f)
self.path = path
def fbenchmark(f, var=[Symbol('x')]):
"""
Do some benchmarks with f using clambdify, lambdify and psyco.
"""
global cf, pf, psyf
start = time()
cf = clambdify(var, f)
print('compile time (including sympy overhead): %f s' % (
time() - start))
pf = lambdify(var, f, 'math')
psyf = None
psyco = import_module('psyco')
if psyco:
psyf = lambdify(var, f, 'math')
psyco.bind(psyf)
code = '''for x in (i/1000. for i in range(1000)):
f(%s)''' % ('x,'*len(var)).rstrip(',')
t1 = Timer(code, 'from __main__ import cf as f')
t2 = Timer(code, 'from __main__ import pf as f')
if psyf:
t3 = Timer(code, 'from __main__ import psyf as f')
else:
t3 = None
print('for x = (0, 1, 2, ..., 999)/1000')
print('20 times in 3 runs')
print('compiled: %.4f %.4f %.4f' % tuple(t1.repeat(3, 20)))
print('Python lambda: %.4f %.4f %.4f' % tuple(t2.repeat(3, 20)))
if t3:
print('Psyco lambda: %.4f %.4f %.4f' % tuple(t3.repeat(3, 20)))
def test_imag_real():
f_re = lambdify([z], sympy.re(z))
val = 3+2j
assert f_re(val) == val.real
f_im = lambdify([z], sympy.im(z)) # see #15400
assert f_im(val) == val.imag
def run_Lagrange_interp_abs_conv(N=[3, 6, 12, 24]):
f = sm.abs(1-2*x)
f = sm.sin(2*sm.pi*x)
fn = sm.lambdify([x], f, modules='numpy')
resolution = 50001
import numpy as np
xcoor = np.linspace(0, 1, resolution)
fcoor = fn(xcoor)
Einf = []
E2 = []
h = []
for _N in N:
psi, points = Lagrange_polynomials_01(x, _N)
u = interpolation(f, psi, points)
un = sm.lambdify([x], u, modules='numpy')
ucoor = un(xcoor)
e = fcoor - ucoor
Einf.append(e.max())
E2.append(np.sqrt(np.sum(e*e/e.size)))
h.append(1./_N)
print Einf
print E2
print h
print N
# Assumption: error = CN**(-N)
print 'convergence rates:'
for i in range(len(E2)):
C1 = E2[i]/(N[i]**(-N[i]/2))
C2 = Einf[i]/(N[i]**(-N[i]/2))
print N[i], C1, C2
def test_numpy_matrix():
if not numpy:
skip("numpy not installed.")
A = Matrix([[x, x*y], [sin(z) + 4, x**z]])
sol_arr = numpy.array([[1, 2], [numpy.sin(3) + 4, 1]])
#Lambdify array first, to ensure return to array as default
f = lambdify((x, y, z), A, ['numpy'])
numpy.testing.assert_allclose(f(1, 2, 3), sol_arr)
#Check that the types are arrays and matrices
assert isinstance(f(1, 2, 3), numpy.ndarray)
# gh-15071
class dot(Function):
pass
x_dot_mtx = dot(x, Matrix([[2], [1], [0]]))
f_dot1 = lambdify(x, x_dot_mtx)
inp = numpy.zeros((17, 3))
assert numpy.all(f_dot1(inp) == 0)
strict_kw = dict(allow_unknown_functions=False, inline=True, fully_qualified_modules=False)
p2 = NumPyPrinter(dict(user_functions={'dot': 'dot'}, **strict_kw))
f_dot2 = lambdify(x, x_dot_mtx, printer=p2)
assert numpy.all(f_dot2(inp) == 0)
p3 = NumPyPrinter(strict_kw)
# The line below should probably fail upon construction (before calling with "(inp)"):
raises(Exception, lambda: lambdify(x, x_dot_mtx, printer=p3)(inp))
def calc_eigs_numerically(mat,h,k,l,S=1):
"""
Give it a matrix, and the (h,k,l) values to substitute into that matrix, each in a separate list.
S is automatically evaluated as one, but can be changed. h,k,l lists must be the same length.
"""
#get rid of these
S_SYM = sympy.Symbol('S')
KX_SYM = sympy.Symbol('kx')
KY_SYM = sympy.Symbol('ky')
KZ_SYM = sympy.Symbol('kz')
#lambdification functionality
syms = (S_SYM,KX_SYM,KY_SYM,KZ_SYM)
matsym = mat.tolist()
func = sympy.lambdify(syms,matsym,modules=["sympy"])
eigarr = []
Slist = S*N.ones(h.shape)
# reduce symbolic matrix to numerical matrix and calculate the eigenvalues
for i in range(len(h)):
eigmat = N.array(func(Slist[i],h[i],k[i],l[i]))
# Convert numpy array to sympy matrix and lambdify it to
# exchange sympy.I with numpy's 1j. Then convert it back to
# a numpy array and append it to the list of eigs.
eigmat = sympy.Matrix(eigmat)
I2jfunc = sympy.lambdify((sympy.I),eigmat,modules="numpy")
eigmat = N.array(I2jfunc(1j))
eigs,vects = N.linalg.eig(eigmat)
eigarr.append(eigs)
return N.array(eigarr)
def error_of_methods():
"""
Complie test with returning error
"""
import math
import numpy as np
import sympy
from sympy import cos
from sympy import sin
from sympy.utilities.lambdify import lambdify
w,x, L ,t= sympy.symbols("w x L t")
pi = math.pi
u = lambda x,t : cos(w*t)*cos(pi*x/L)
q = lambda x : 1 + ( x -L/2.0)**4
def source_term(u,q):
return sympy.simplify(u(x,t).diff(t, t) - (u(x,t).diff(x)*q(x)).diff(x) )
w=1
L = 2
T=10
Nx=40
f = sympy.lambdify((x,t), source_term(u,q) ,'numpy')
q = sympy.lambdify(x,q(x) ,'numpy')
I = sympy.lambdify(x, u(x,t).subs(t,0),'numpy')
u = sympy.lambdify((x,t), u(x,t),'numpy')
print solve_wave_eqn_with_variable_velocity(q,f,I, L,T,Nx,u_exact=u,neumann=sum_approximation)[1]
print solve_wave_eqn_with_variable_velocity(q,f,I, L,T,Nx,u_exact=u,neumann=centered_difference)[1]
print solve_wave_eqn_with_variable_velocity(q,f,I, L,T,Nx,u_exact=u,neumann=centered_difference)[1]
print solve_wave_eqn_with_variable_velocity(q,f,I, L,T,Nx,u_exact=u,neumann=shifted_domain)[1]
def test_matrix():
A = Matrix([[x, x*y], [sin(z)+4, x**z]])
sol = Matrix([[1, 2], [sin(3)+4, 1]])
f = lambdify((x,y,z), A, modules="sympy")
assert f(1,2,3) == sol
f = lambdify((x,y,z), (A, [A]), modules="sympy")
assert f(1,2,3) == (sol,[sol])
def run_Lagrange_interp_abs_Cheb(N, ymin=None, ymax=None):
f = sp.Abs(1-2*x)
fn = sp.lambdify([x], f)
psi, points= Lagrange_polynomials(x, N, [0, 1],
point_distribution='Chebyshev')
u = interpolation(f, psi, points)
comparison_plot(f, u, Omega=[0, 1],
filename='Lagrange_interp_abs_Cheb_%d' % (N+1),
plot_title='Interpolation by Lagrange polynomials '\
'of degree %d' % N, ymin=ymin, ymax=ymax)
print 'Interpolation points:', points
# Make figures of Lagrange polynomials (psi)
plt.figure()
xcoor = np.linspace(0, 1, 1001)
legends = []
for i in (2, (N+1)/2+1):
fn = sp.lambdify([x], psi[i])
ycoor = fn(xcoor)
plt.plot(xcoor, ycoor)
legends.append(r'$\psi_%d$' % i)
plt.hold('on')
plt.legend(legends)
plt.plot(points, [0]*len(points), 'ro')
#if ymin is not None and ymax is not None:
# axis([xcoor[0], xcoor[-1], ymin, ymax])
plt.savefig('Lagrange_basis_Cheb_%d.pdf' % (N+1))
plt.savefig('Lagrange_basis_Cheb_%d.png' % (N+1))
def _interpret_args(self, args, kwargs):
f, gradient = None, self.gradient
atoms, lists = self._sort_args(args)
s = self._pop_symbol_list(lists)
s = self._fill_in_vars(s)
# prepare the error message for lambdification failure
f_str = ', '.join(str(fa) for fa in atoms)
s_str = (str(sa) for sa in s)
s_str = ', '.join(sa for sa in s_str if sa.find('unbound') < 0)
f_error = ValueError("Could not interpret arguments "
"%s as functions of %s." % (f_str, s_str))
# try to lambdify args
if len(atoms) == 1:
fv = atoms[0]
try: f = lambdify(s, [fv,fv,fv])
except: raise f_error
elif len(atoms) == 3:
fr, fg, fb = atoms
try: f = lambdify(s, [fr,fg,fb])
except: raise f_error
else: raise ValueError("A ColorScheme must provide 1 or 3 "
"functions in x, y, z, u, and/or v.")
# try to intrepret any given color information
if len(lists) == 0:
gargs = []
elif len(lists) == 1:
gargs = lists[0]
elif len(lists) == 2:
try: (r1,g1,b1), (r2,g2,b2) = lists
except: raise ValueError("If two color arguments are given, "
"they must be given in the format "
"(r1,g1,b1), (r2,g2,b2).")
gargs = lists
elif len(lists) == 3:
try: (r1,r2), (g1,g2), (b1,b2) = lists
except: raise ValueError("If three color arguments are given, "
"they must be given in the format "
"(r1,r2), (g1,g2), (b1,b2). To create "
"a multi-step gradient, use the syntax "
"[0, colorStart, step1, color1, ..., 1, "
"colorEnd].")
gargs = [[r1,g1,b1], [r2,g2,b2]]
else: raise ValueError("Don't know what to do with collection "
"arguments %s." % (', '.join(str(l) for l in lists)))
if gargs:
try: gradient = ColorGradient(*gargs)
except Exception, ex:
raise ValueError(("Could not initialize a gradient "
"with arguments %s. Inner "
"exception: %s") % (gargs, str(ex)))
def interpolation(f, phi, points):
"""
Given a function f(x), return the approximation to
f(x) in the space V, spanned by phi, that interpolates
f at the given points. Must have len(points) = len(phi)
"""
N = len(phi) - 1
A = sm.zeros((N+1, N+1))
b = sm.zeros((N+1, 1))
# Wrap phi and f in Python functions rather than expressions
# so that we can evaluate phi at points[i] (alternative to subs?)
x = sm.Symbol('x')
phi = [sm.lambdify([x], phi[i]) for i in range(N+1)]
f = sm.lambdify([x], f)
print '...evaluating matrix...'
for i in range(N+1):
for j in range(N+1):
print '(%d,%d)' % (i, j)
A[i,j] = phi[j](points[i])
b[i,0] = f(points[i])
print
print 'A:\n', A, '\nb:\n', b
c = A.LUsolve(b)
print 'coeff:', c
u = 0
for i in range(len(phi)):
u += c[i,0]*phi[i](x)
# Alternative:
# u = sum(c[i,0]*phi[i] for i in range(len(phi)))
print 'approximation:', u
return u
def test_scipy_fns():
if not scipy:
skip("scipy not installed")
single_arg_sympy_fns = [erf, erfc, factorial, gamma, loggamma, digamma]
single_arg_scipy_fns = [scipy.special.erf, scipy.special.erfc,
scipy.special.factorial, scipy.special.gamma, scipy.special.gammaln,
scipy.special.psi]
numpy.random.seed(0)
for (sympy_fn, scipy_fn) in zip(single_arg_sympy_fns, single_arg_scipy_fns):
test_values = 20 * numpy.random.rand(20)
f = lambdify(x, sympy_fn(x), modules = "scipy")
assert numpy.all(abs(f(test_values) - scipy_fn(test_values)) < 1e-15)
double_arg_sympy_fns = [RisingFactorial, besselj, bessely, besseli,
besselk]
double_arg_scipy_fns = [scipy.special.poch, scipy.special.jn,
scipy.special.yn, scipy.special.iv, scipy.special.kn]
#suppress scipy warnings
import warnings
warnings.filterwarnings('ignore', '.*floating point number truncated*')
for (sympy_fn, scipy_fn) in zip(double_arg_sympy_fns, double_arg_scipy_fns):
for i in range(20):
test_values = 20 * numpy.random.rand(2)
f = lambdify((x,y), sympy_fn(x,y), modules = "scipy")
assert abs(f(*test_values) - scipy_fn(*test_values)) < 1e-15
def least_squares(f, psi, Omega, symbolic=True, print_latex=False):
"""
Given a function f(x,y) on a rectangular domain
Omega=[[xmin,xmax],[ymin,ymax]],
return the best approximation to f(x,y) in the space V
spanned by the functions in the list psi.
"""
N = len(psi) - 1
A = sym.zeros((N+1, N+1))
b = sym.zeros((N+1, 1))
x, y = sym.symbols('x y')
print '...evaluating matrix...'
for i in range(N+1):
for j in range(i, N+1):
print '(%d,%d)' % (i, j)
integrand = psi[i]*psi[j]
if symbolic:
I = sym.integrate(integrand,
(x, Omega[0][0], Omega[0][1]),
(y, Omega[1][0], Omega[1][1]))
if not symbolic or isinstance(I, sym.Integral):
# Could not integrate symbolically, use numerical int.
print 'numerical integration of', integrand
integrand = sym.lambdify([x,y], integrand)
I = sym.mpmath.quad(integrand,
[Omega[0][0], Omega[0][1]],
[Omega[1][0], Omega[1][1]])
A[i,j] = A[j,i] = I
integrand = psi[i]*f
if symbolic:
I = sym.integrate(integrand,
(x, Omega[0][0], Omega[0][1]),
(y, Omega[1][0], Omega[1][1]))
if not symbolic or isinstance(I, sym.Integral):
# Could not integrate symbolically, use numerical int.
print 'numerical integration of', integrand
integrand = sym.lambdify([x,y], integrand)
I = sym.mpmath.quad(integrand,
[Omega[0][0], Omega[0][1]],
[Omega[1][0], Omega[1][1]])
b[i,0] = I
print
print 'A:\n', A, '\nb:\n', b
if symbolic:
c = A.LUsolve(b) # symbolic solve
# c is a sympy Matrix object, numbers are in c[i,0]
c = [c[i,0] for i in range(c.shape[0])]
else:
c = sym.mpmath.lu_solve(A, b) # numerical solve
print 'coeff:', c
u = sum(c[i]*psi[i] for i in range(len(psi)))
print 'approximation:', u
print 'f:', sym.expand(f)
if print_latex:
print sym.latex(A, mode='plain')
print sym.latex(b, mode='plain')
print sym.latex(c, mode='plain')
return u, c
def __init__(self,
fi=lambda t, theta: log(t),
fi_inv=None, #lambda t, theta:(-sympy.log(t)) ** theta,
theta=2,
marginals=None):
self.theta = float(theta)#Symbol('theta')
self.t = Symbol('t')
self.s = Symbol('s')
self.d = len(marginals)
self.fi_ = fi
self.fi_inv_ = fi_inv
self.sym_fi = fi(self.t, self.theta)
self.sym_fi_deriv = sympy.diff(self.sym_fi, self.t)
if fi_inv is None:
self.sym_fi_inv = sympy.solve(self.sym_fi - self.s, self.t)[0]
else:
self.sym_fi_inv = fi_inv(self.s, self.theta)
self.sym_fi_inv_nth_deriv = sympy.diff(self.sym_fi_inv, self.s, self.d)
#self.debug_info()
super(ArchimedeanSymbolicCopula, self).__init__(fi=sympy.lambdify(self.t, self.sym_fi, "numpy"),
fi_deriv=sympy.lambdify(self.t, self.sym_fi_deriv, "numpy"),
fi_inv=sympy.lambdify(self.s, self.sym_fi_inv, "numpy"),
fi_inv_nth_deriv=sympy.lambdify(self.s, self.sym_fi_inv_nth_deriv, "numpy"),
marginals=marginals)
vars = self.symVars
si = 0
for i in range(self.d):
si += self.fi_(vars[i], self.theta)
self.sym_C = self.fi_inv_(si, self.theta)
def initialize(self, args):
self.E = args[0]
self.A = args[1]
self.I = args[2]
self.r = args[3]
self.rho = args[4]
self.l = args[5]
self.g = args[6]
q = sym.Matrix(sym.symarray('q',6))
E, A, I, r, rho, l, g = sym.symbols('E A I r rho l g')
theta = sym.Matrix(['theta_1','theta_2'])
omega = sym.Matrix(['omega_1','omega_2'])
# Load symbolic needed matricies and vectors
M_sym = pickle.load( open( "gebf-mass-matrix.dump", "rb" ) )
beta_sym = pickle.load( open( "gebf-force-vector.dump", "rb" ) )
Gamma1_sym = pickle.load( open( "gebf-1c-matrix.dump", "rb" ) )
Gamma2_sym = pickle.load( open( "gebf-2c-matrix.dump", "rb" ) )
# Create numeric function of needed matrix and vector quantities
# this is MUCH MUCH faster than .subs()
# .subs() is unusably slow !!
self.M = lambdify((E, A, I, r, rho, l, g, q, theta, omega), M_sym, "numpy")
self.beta = lambdify((E, A, I, r, rho, l, g, q, theta, omega), beta_sym, "numpy")
self.Gamma1 = lambdify((E, A, I, r, rho, l, g, q, theta, omega), Gamma1_sym, "numpy")
self.Gamma2 = lambdify((E, A, I, r, rho, l, g, q, theta, omega), Gamma2_sym, "numpy")
def Newton_solver_pq(error, hx, ht, gx, gt, x0):
p, q = symbols('p q')
epsilon1 = gx*hx[-2]**p + gt*ht[-2]**q - error[-2]
epsilon2 = gx*hx[-1]**p + gt*ht[-1]**q - error[-1]
epsilon = [epsilon1, epsilon2]
x = [p, q]
def f(i,j):
return diff(epsilon[i], x[j])
Jacobi = Matrix(2, 2, f)
JacobiInv = Jacobi.inv()
epsilonfunc = lambdify(x, epsilon)
JacobiInvfunc = lambdify(x, JacobiInv)
x = x0
F = np.asarray(epsilonfunc(x))
for n in range(8):
Jinv = np.asarray(JacobiInvfunc(x))
F = np.asarray(epsilonfunc(x))
x = x - np.dot(Jinv, F)
return x
def PlotFor2Param(k1, k2, x, y, yVal, eq1, eq2, eqDet, eqTr, valK1m, valK3m, valK2 = 0.95, valK3 = 0.0032):
eqk1_1Det = solve(eqDet.subs(x, eq2), k1)
eqForK1Det = eq1 - eqk1_1Det[0]
eqK2Det = solve(eqForK1Det.subs(km1, valK1m).subs(km3, valK3m).subs(k3, valK3), k2)
funcK2Det = lambdify(y, eqK2Det[0])
funcK1Det = lambdify(y, eqk1_1Det[0].subs(x, eq2).subs(k2, eqK2Det[0]).subs(km1, valK1m).subs(km3, valK3m).subs(k3, valK3))
k1DetAll = funcK1Det(yVal)
k2DetAll = funcK2Det(yVal)
k1DetPos = [k1DetAll[i] for i in range(len(k1DetAll)) if k1DetAll[i] > 0 and k2DetAll[i] > 0]
k2DetPos = [k2DetAll[i] for i in range(len(k2DetAll)) if k1DetAll[i] > 0 and k2DetAll[i] > 0]
hopf, = plt.plot(k1DetPos, k2DetPos, linestyle = '--', color = 'r', label = 'hopf line')
eqk1_1Tr = solve(eqTr.subs(x, eq2), k1)
eqForK1Tr = eq1 - eqk1_1Tr[0]
eqK2Tr = solve(eqForK1Tr.subs(km1, valK1m).subs(km3, valK3m).subs(k3, valK3), k2)
funcK2Tr = lambdify(y, eqK2Tr[0])
funcK1Tr = lambdify(y, eq1.subs(x, eq2).subs(k2, eqK2Tr[0]).subs(km1, valK1m).subs(km3, valK3m).subs(k3, valK3))
k1AllTr = funcK1Tr(yVal)
k2AllTr = funcK2Tr(yVal)
k1PosTr = [k1AllTr[i] for i in range(len(k1AllTr)) if k1AllTr[i] > 0 and k2AllTr[i] > 0]
print(len(k1PosTr))
k2PosTr = [k2AllTr[i] for i in range(len(k2AllTr)) if k1AllTr[i] > 0 and k2AllTr[i] > 0]
print(len(k2PosTr))
sadle, = plt.plot(k1PosTr, k2PosTr, color = 'g', label = 'sadle-nodle line')
plt.xlim([0, 2])
plt.ylim([0,5])
plt.legend(handles=[hopf, sadle])
plt.xlabel('k1')
plt.ylabel('k2')
plt.show()
def fbenchmark(f, var=[Symbol("x")]):
"""
Do some benchmarks with f using clambdify, lambdify and psyco.
"""
global cf, pf, psyf
start = time()
cf = clambdify(var, f)
print "compile time (including sympy overhead): %f s" % (time() - start)
pf = lambdify(var, f, "math")
psyf = None
try:
import psyco
psyf = lambdify(var, f, "math")
psyco.bind(psyf)
except ImportError:
pass
code = """for x in (i/1000. for i in range(1000)):
f(%s)""" % (
"x," * len(var)
).rstrip(
","
)
t1 = Timer(code, "from __main__ import cf as f")
t2 = Timer(code, "from __main__ import pf as f")
if psyf:
t3 = Timer(code, "from __main__ import psyf as f")
else:
t3 = None
print "for x = (0, 1, 2, ..., 999)/1000"
print "20 times in 3 runs"
print "compiled: %.4f %.4f %.4f" % tuple(t1.repeat(3, 20))
print "Python lambda: %.4f %.4f %.4f" % tuple(t2.repeat(3, 20))
if t3:
print "Psyco lambda: %.4f %.4f %.4f" % tuple(t3.repeat(3, 20))
def Newton_solver_gxgt(error, hx, ht, x0, p_value=1, q_value=1):
gx, gt, p, q, hx1, hx2, ht1, ht2 = symbols('gx gt p q qhx1 hx2 ht1 ht2')
epsilon1 = gx*hx1**p + gt*ht1**q - error[-2]
epsilon2 = gx*hx2**p + gt*ht2**q - error[-1]
epsilon = [epsilon1, epsilon2]
x = [gx, gt]
knowns = [p, q, hx1, hx2, ht1, ht2]
def f(i,j):
return diff(epsilon[i], x[j])
Jacobi = Matrix(2, 2, f)
JacobiInv = Jacobi.inv()
epsilonfunc = lambdify([x, knowns], epsilon)
JacobiInvfunc = lambdify([x, knowns], JacobiInv)
x = x0
knowns = [p_value, q_value, hx[-2], hx[-1], ht[-2], ht[-1]]
F = np.asarray(epsilonfunc(x, knowns))
for n in range(8):
Jinv = np.asarray(JacobiInvfunc(x, knowns))
F = np.asarray(epsilonfunc(x, knowns))
x = x - np.dot(Jinv, F)
print "n, x: ", n, x
return x
def velocity_field(psi): #takes a symbolic function and returns two lambda functions
#to evaluate the derivatives in both x and y.
global w
if velocity_components:
u = lambdify((x,y), eval(x_velocity), modules='numpy')
v = lambdify((x,y), eval(y_velocity), modules='numpy')
else:
if is_complex_potential:
print "Complex potential, w(z) given"
#define u, v symbolically as the imaginary part of the derivatives
u = lambdify((x, y), sympy.im(psi.diff(y)), modules='numpy')
v = lambdify((x, y), -sympy.im(psi.diff(x)), modules='numpy')
else:
#define u,v as the derivatives
print "Stream function, psi given"
u = sympy.lambdify((x, y), psi.diff(y), 'numpy')
v = sympy.lambdify((x, y), -psi.diff(x), 'numpy')
if (branch_cuts): # If it's indicated that there are branch cuts in the mapping,
# then we need to return vectorized numpy functions to evaluate
# everything numerically, instead of symbolically
# This of course results in a SIGNIFICANT time increase
# (I don't know how to handle more than the primitive root
# (symbolically in Sympy
return np.vectorize(u),np.vectorize(v)
else:
# If there are no branch cuts, then return the symbolic lambda functions (MUCH faster)
return u,v
def __init__(self, s=1, h1=0.2, h2=0.6, h3=0.2, v1=1, v2=1, v3=1,
base=None):
"""Inputs: s - the stratification parameter
h1 - depth of layer 1
h2 - depth of layer 2
h3 - depth of layer 3
v1 - speed relation for layer 1
v2 - speed relation for layer 2
v3 - speed relation for layer 3.
base - optional precalculated base equation set
"""
# Create functions of (a, b) for these given parameters
self.F = self.F(v1=v1, v2=v2, v3=v3, h1=h1, h2=h2, h3=h3, s=s)
self.G = self.G(v1=v1, v2=v2, v3=v3, h1=h1, h2=h2, h3=h3)
self.f = sp.lambdify((a, b), self.F)
self.g = sp.lambdify((a, b), self.G)
self.H = h1, h2, h3
self.V = v1, v2, v3
self.base = base or LambBase(s=s, h1=h1, h2=h2, h3=h3)
# Sample grid for finding F(a, b) = 0
# resolution of rough zero search (np.arange)
self.resolution = 0.01
# bounds on physical solutions
a_min, a_max = (-h1, 1 - h1)
b_min, b_max = (-(h1 + h2), h3)
s = 2 * self.resolution # extra edge to consider
x = np.arange(a_min - s, a_max + s, self.resolution)
y = np.arange(b_min - s, b_max + s, self.resolution)
self.AB = np.meshgrid(x, y)
def test_curly_matrix_symbol():
# Issue #15009
curlyv = sympy.MatrixSymbol("{v}", 2, 1)
lam = lambdify(curlyv, curlyv)
assert lam(1)==1
lam = lambdify(curlyv, curlyv, dummify=True)
assert lam(1)==1
def make_numpy_fns_of_d1d2xw(self, dg_first, dg_second):
args = self.normal_x_s_d.values() + self.normal_w_s_d.values() + \
self.param_sym_dict.values()
args_values_x = [x.subs(self.normal_xw_s_ss_values_d)
for x in self.normal_x_s_d.values()]
args_values_w = [w.subs(self.normal_xw_s_ss_values_d)
for w in self.normal_w_s_d.values()]
args_values_p = [p.subs(self.par_to_values_dict)
for p in self.param_sym_dict.values()]
args_values = args_values_x + args_values_w + args_values_p
# print '\nargs for lambdify:', args
# print '\nargs values for lambdify:', args_values
# print '\nself.normal_xw_s_ss_values_d:', self.normal_xw_s_ss_values_d
# print '\nself.par_to_values_dict:', self.par_to_values_dict
dg_first_lam = sympy.lambdify(args, dg_first, dummify=False)
dg_second_lam = sympy.lambdify(args, dg_second, dummify=False)
return dg_first_lam, dg_second_lam, args_values
def derivative_matrix(deg, basis_functions, unroll=True):
'''
Matrix of \int_{-1}^{1}(L_i, L_j`) for polynomials spanned by deg+1
basis_functions.
'''
# Numerical quadrature, mas degree of integrand 2*deg - 1 -> deg
xq, wq = np.polynomial.legendre.leggauss(deg)
# Fast eval of basis and asis derivative
x = Symbol('x')
basis = [lambdify(x, f, 'numpy') for f in basis_functions(deg)]
dbasis = [lambdify(x, f.diff(x, 1), 'numpy') for f in basis_functions(deg)]
# Save calls to eval
if unroll:
V = np.zeros((len(basis), len(xq)))
# Basis functions evaluated in quadrature points
for row, f in enumerate(basis): V[row, :] = f(xq)
dV = np.zeros((len(xq), len(basis)))
# Basis derivatives evaluated in quadrature points
for col, df in enumerate(dbasis): dV[:, col] = df(xq)
# Integrate
C = (wq*V).dot(dV)
# Here there are more calls to eval
else:
C = np.zeros((len(basis), len(basis)))
for i, v in enumerate(basis):
for j, du in enumerate(dbasis):
C[i, j] = np.sum(wq*v(xq)*du(xq))
return C
def make_integral(f_str):
x = sympy.Symbol('x')
func_expr = sympy.sympify(f_str)
f = sympy.lambdify(x, func_expr)
int_expr = sympy.integrate(func_expr)
F = sympy.lambdify(x, int_expr)
return f, F
def make_numpy_fns_of_d1d2xw(self, dg_first, dg_second):
args_x = self.xvar_tp1_sym + self.xvar_t_sym + self.xvar_tm1_sym
args_w = self.wvar_tp1_sym + self.wvar_t_sym
args = args_x + args_w + self.param_sym_dict.values()
# args_values_x = [x.subs(self.normal_xw_s_ss_values_d)
# for x in args_x]
# args_values_w = [x.subs(self.normal_xw_s_ss_values_d)
# for x in args_w]
# args_values_p = [p.subs(self.par_to_values_dict)
# for p in self.param_sym_dict.values()]
# args_values = args_values_x + args_values_w + args_values_p
dg_first_lam = sympy.lambdify(args, dg_first)
dg_second_lam = sympy.lambdify(args, dg_second)
self.fun_d_first_numpy = dg_first_lam
self.fun_d_second_numpy = dg_second_lam
return dg_first_lam, dg_second_lam
def test_quadratic():
"""Verify a quadratic solution."""
I = 1.2; V = 3; m = 2; b = 0.9
s = lambda u: 4*u
t = sym.Symbol('t')
dt = 0.2
T = 2
q = 2 # arbitrary constant
u_exact = I + V*t + q*t**2
F = sym.lambdify(t, lhs_eq(t, m, b, s, u_exact, 'linear'))
u_exact = sym.lambdify(t, u_exact, modules='numpy')
#u1, t1 = solver(I, V, m, b, s, F, dt, T, 'linear')
u1, t1 = solver_bwdamping(I, V, m, b, s, F, dt, T, 'linear')
diff = np.abs(u_exact(t1) - u1).max()
print diff
tol = 1E-13
#assert diff < tol
# In the quadratic damping case, u_exact must be linear
# in order to exactly recover this solution
u_exact = I + V*t
F = sym.lambdify(t, lhs_eq(t, m, b, s, u_exact, 'quadratic'))
u_exact = sym.lambdify(t, u_exact, modules='numpy')
#u2, t2 = solver(I, V, m, b, s, F, dt, T, 'quadratic')
u2, t2 = solver_bwdamping(I, V, m, b, s, F, dt, T, 'quadratic')
diff = np.abs(u_exact(t2) - u2).max()
print diff
assert diff < tol
def make_derivative(f_str):
x = sympy.Symbol('x')
func_expr = sympy.sympify(f_str)
f = sympy.lambdify(x, func_expr)
deriv_expr = sympy.diff(func_expr)
df = sympy.lambdify(x, deriv_expr)
return f, df
def comparison_plot(f, u, Omega, plotfile='tmp'):
"""Compare f(x,y) and u(x,y) for x,y in Omega in a plot."""
x, y = sm.symbols('x y')
f = sm.lambdify([x,y], f, modules="numpy")
u = sm.lambdify([x,y], u, modules="numpy")
# When doing symbolics, Omega can easily contain symbolic expressions,
# assume .evalf() will work in that case to obtain numerical
# expressions, which then must be converted to float before calling
# linspace below
for r in range(2):
for s in range(2):
if not isinstance(Omega[r][s], (int,float)):
Omega[r][s] = float(Omega[r][s].evalf())
resolution = 41 # no of points in plot
xcoor = linspace(Omega[0][0], Omega[0][1], resolution)
ycoor = linspace(Omega[1][0], Omega[1][1], resolution)
xv, yv = ndgrid(xcoor, ycoor)
# Vectorized functions expressions does not work with
# lambdify'ed functions without the modules="numpy"
exact = f(xv, yv)
approx = u(xv, yv)
figure()
surfc(xv, yv, exact, title='f(x,y)',
colorbar=True, colormap=hot(), shading='flat')
if plotfile:
savefig('%s_f.pdf' % plotfile, color=True)
savefig('%s_f.png' % plotfile)
figure()
surfc(xv, yv, approx, title='f(x,y)',
colorbar=True, colormap=hot(), shading='flat')
if plotfile:
savefig('%s_u.pdf' % plotfile, color=True)
savefig('%s_u.png' % plotfile)
def test_str_args():
f = lambdify('x,y,z', 'z,y,x')
assert f(3, 2, 1) == (1, 2, 3)
assert f(1.0, 2.0, 3.0) == (3.0, 2.0, 1.0)
# make sure correct number of args required
raises(TypeError, lambda: f(0))
def test_bad_args():
# no vargs given
raises(TypeError, lambda: lambdify(1))
# same with vector exprs
raises(TypeError, lambda: lambdify([1, 2]))
phi = basis(d=1)
phi
element_matrix(phi, Omega_e=[0.1, 0.2], symbolic=True)
element_matrix(phi, Omega_e=[0.1, 0.2], symbolic=False)
h, x = sm.symbols('h x')
nodes = [0, h, 2 * h]
elements = [[0, 1], [1, 2]]
phi = basis(d=1)
f = x * (1 - x)
A, b = assemble(nodes, elements, phi, f, symbolic=True)
A
b
c = A.LUsolve(b)
c
fn = sm.lambdify([x], f)
[fn(xc) for xc in nodes]
# The corresponding numerical computations, as done by sympy and
# still based on symbolic integration, goes as follows:
nodes = [0, 0.5, 1]
elements = [[0, 1], [1, 2]]
phi = basis(d=1)
x = sm.Symbol('x')
f = x * (1 - x)
A, b = assemble(nodes, elements, phi, f, symbolic=False)
A
b
c = A.LUsolve(b)
c
def test_atoms():
# Non-Symbol atoms should not be pulled out from the expression namespace
f = lambdify(x, pi + x, {"pi": 3.14})
assert f(0) == 3.14
f = lambdify(x, I + x, {"I": 1j})
assert f(1) == 1 + 1j
def test_Min_Max():
# see gh-10375
assert lambdify((x, y, z), Min(x, y, z))(1, 2, 3) == 1
assert lambdify((x, y, z), Max(x, y, z))(1, 2, 3) == 3
def test_ITE():
assert lambdify((x, y, z), ITE(x, y, z))(True, 5, 3) == 5
assert lambdify((x, y, z), ITE(x, y, z))(False, 5, 3) == 3
def test_issue_2790():
assert lambdify((x, (y, z)), x + y)(1, (2, 4)) == 3
assert lambdify((x, (y, (w, z))), w + x + y + z)(1, (2, (3, 4))) == 10
assert lambdify(x, x + 1, dummify=False)(1) == 2
def test_true_false():
# We want exact is comparison here, not just ==
assert lambdify([], true)() is True
assert lambdify([], false)() is False
def test_lambdify_imps():
# Test lambdify with implemented functions
# first test basic (sympy) lambdify
f = sympy.cos
assert lambdify(x, f(x))(0) == 1
assert lambdify(x, 1 + f(x))(0) == 2
assert lambdify((x, y), y + f(x))(0, 1) == 2
# make an implemented function and test
f = implemented_function("f", lambda x: x + 100)
assert lambdify(x, f(x))(0) == 100
assert lambdify(x, 1 + f(x))(0) == 101
assert lambdify((x, y), y + f(x))(0, 1) == 101
# Can also handle tuples, lists, dicts as expressions
lam = lambdify(x, (f(x), x))
assert lam(3) == (103, 3)
lam = lambdify(x, [f(x), x])
assert lam(3) == [103, 3]
lam = lambdify(x, [f(x), (f(x), x)])
assert lam(3) == [103, (103, 3)]
lam = lambdify(x, {f(x): x})
assert lam(3) == {103: 3}
lam = lambdify(x, {f(x): x})
assert lam(3) == {103: 3}
lam = lambdify(x, {x: f(x)})
assert lam(3) == {3: 103}
# Check that imp preferred to other namespaces by default
d = {'f': lambda x: x + 99}
lam = lambdify(x, f(x), d)
assert lam(3) == 103
# Unless flag passed
lam = lambdify(x, f(x), d, use_imps=False)
assert lam(3) == 102
def test_own_module():
f = lambdify(x, sin(x), math)
assert f(0) == 0.0
def test_sym_integral():
f = Lambda(x, exp(-x**2))
l = lambdify(x, Integral(f(x), (x, -oo, oo)), modules="sympy")
assert l(y).doit() == sqrt(pi)
def test_own_namespace():
myfunc = lambda x: 1
f = lambdify(x, sin(x), {"sin": myfunc})
assert f(0.1) == 1
assert f(100) == 1
def test_sym_single_arg():
f = lambdify(x, x * y)
assert f(z) == z * y
def test_sym_list_args():
f = lambdify([x, y], x + y + z)
assert f(1, 2) == 3 + z
else:
if n == 0:
return 0
else:
return -1 / (n * np.pi)
t = sp.Symbol("t")
f0 = sp.Symbol("f0")
# dit zijn de formules voor de driehoeksgolf, zaagtandgolf en een sinus
D = 4 * sp.Abs(f0 * t + 1 / 4 - sp.floor(f0 * t + 3 / 4)) - 1
Z = f0 * t - sp.floor(f0 * t) - 1 / 2
Sin = sp.sin(2 * sp.pi * f0 * t)
Dt = sp.lambdify([t, f0], D, "numpy")
Zt = sp.lambdify([t, f0], Z, "numpy")
Sint = sp.lambdify([t, f0], Sin, "numpy")
print("setup klaar")
fig1 = plt.figure("figuur 1", dpi=500)
twaarden = np.linspace(0, 2, 10000)
f0waarde = 2
line1, = plt.plot(twaarden, Dt(twaarden, f0waarde))
line2, = plt.plot(twaarden, Zt(twaarden, f0waarde))
line3, = plt.plot(twaarden, Sint(twaarden, f0waarde))
plt.xlim(0, 2)
def test_integral():
f = Lambda(x, exp(-x**2))
l = lambdify(x, Integral(f(x), (x, -oo, oo)), modules="sympy")
assert l(x) == Integral(exp(-x**2), (x, -oo, oo))
def test_trig_symbolic():
f = lambdify([x], [cos(x), sin(x)])
d = f(pi)
assert abs(d[0] + 1) < 0.0001
assert abs(d[1] - 0) < 0.0001
def test_number_precision():
mpmath.mp.dps = 50
sin02 = mpmath.mpf("0.19866933079506121545941262711838975037020672954020")
f = lambdify(x, sin02, "mpmath")
prec = 1e-49 # mpmath precision is around 50 decimal places
assert -prec < f(0) - sin02 < prec
def test_vector_discontinuous():
f = lambdify(x, (-1 / x, 1 / x))
raises(ZeroDivisionError, lambda: f(0))
assert f(1) == (-1.0, 1.0)
assert f(2) == (-0.5, 0.5)
assert f(-2) == (0.5, -0.5)
def test_python_div_zero_issue_11306():
if not numpy:
skip("numpy not installed.")
p = Piecewise((1 / x, y < -1), (x, y <= 1), (1 / x, True))
lambdify([x, y], p, modules='numpy')(0, 1)
def test_vector_simple():
f = lambdify((x, y, z), (z, y, x))
assert f(3, 2, 1) == (1, 2, 3)
assert f(1.0, 2.0, 3.0) == (3.0, 2.0, 1.0)
# make sure correct number of args required
raises(TypeError, lambda: f(0))
def test_list_args():
f = lambdify([x, y], x + y)
assert f(1, 2) == 3
def test_single_arg():
f = lambdify(x, 2 * x)
assert f(1) == 2
def test_numpy_inverse():
if not numpy:
skip("numpy not installed.")
A = Matrix([[1, x], [0, 1]])
f = lambdify((x), A**-1, modules="numpy")
numpy.testing.assert_array_equal(f(2), numpy.array([[1, -2], [0, 1]]))
def test_sin():
f = lambdify(x, sin(x)**2)
assert isinstance(f(2), float)
f = lambdify(x, sin(x)**2, modules="math")
assert isinstance(f(2), float)
def test_numpy_transpose():
if not numpy:
skip("numpy not installed.")
A = Matrix([[1, x], [0, 1]])
f = lambdify((x), A.T, modules="numpy")
numpy.testing.assert_array_equal(f(2), numpy.array([[1, 0], [2, 1]]))
def test_no_args():
f = lambdify([], 1)
raises(TypeError, lambda: f(-1))
assert f() == 1
def test_math():
f = lambdify((x, y), sin(x), modules="math")
assert f(0, 5) == 0
t = sympy.symbols("t", real=True)
x = ss.ChiSquared("x", 1)
"""
To get the left side of the Chebyshev inequality, we have to write this out
as the following conditional probability,
"""
r = ss.P((x - 1) > t, x > 1) + ss.P(-(x - 1) > t, x < 1)
"""
Note that we cannot use vectorized inputs for the lambdify function because it contains embedded functions that are only
available in Sympy. Otherwise, we could have used lambdify(t,fw,numpy) to specify the corresponding functions in Numpy
to use for the expression.
This is because of certain limitations in the statistics module at this point in its devel- opment regarding the
absolute value function. We could take the above expression, which is a function of t and attempt to compute the
integral, but that would take a very long time (the expression is very long and complicated, which is why we did
not print it out above). This is because Sympy is a pure-python module that does not utilize any C-level optimizations
under the hood. In this situation, it’s better to use the built-in cumulative density function as in the following
(after some rearrangement of the terms),
"""
w = (1 - ss.cdf(x) * (t + 1)) + ss.cdf(x) * (1 - t)
fw = sympy.lambdify(t, w)
"""
To plot this, we can evaluate it at a variety of t values by using the .subs substitution method, but it is more
convenient to use the lambdify method to convert the expression to a function.
"""
map(fw, [0, 1, 2, 3, 4])
def test_trig_float():
f = lambdify([x], [cos(x), sin(x)])
d = f(3.14159)
assert abs(d[0] + 1) < 0.0001
assert abs(d[1] - 0) < 0.0001
