def sample2d(f, x_args):
"""
Samples a 2d function f over specified intervals and returns two
arrays (X, Y) suitable for plotting with matlab (matplotlib)
syntax. See examples\mplot2d.py.
f is a function of one variable, such as x**2.
x_args is an interval given in the form (var, min, max, n)
"""
try:
f = Basic.sympify(f)
except:
raise ValueError("f could not be interpretted as a SymPy function")
try:
x, x_min, x_max, x_n = x_args
except:
raise ValueError("x_args must be a tuple of the form (var, min, max, n)")
x_l = float(x_max - x_min)
x_d = x_l/float(x_n)
X = arange(float(x_min), float(x_max)+x_d, x_d)
Y = empty(len(X))
for i in range(len(X)):
try:
Y[i] = float(f.subs(x, X[i]))
except:
Y[i] = None
return X, Y
def set_v_max(self, v_max):
if v_max is None:
self._v_max = None
return
try:
self._v_max = Basic.sympify(v_max)
float(self._v_max.evalf())
except:
raise ValueError("v_max could not be interpreted as a number.")
def set_v_min(self, v_min):
if v_min is None:
self._v_min = None
return
try:
self._v_min = Basic.sympify(v_min)
float(self._v_min.evalf())
except:
raise ValueError("v_min could not be interpreted as a number.")
def sample3d(f, x_args, y_args):
"""
Samples a 3d function f over specified intervals and returns three
2d arrays (X, Y, Z) suitable for plotting with matlab (matplotlib)
syntax. See examples\mplot3d.py.
f is a function of two variables, such as x**2 + y**2.
x_args and y_args are intervals given in the form (var, min, max, n)
"""
x, x_min, x_max, x_n = None, None, None, None
y, y_min, y_max, y_n = None, None, None, None
try:
f = Basic.sympify(f)
except:
raise ValueError("f could not be interpretted as a SymPy function")
try:
x, x_min, x_max, x_n = x_args
y, y_min, y_max, y_n = y_args
except:
raise ValueError("x_args and y_args must be tuples of the form (var, min, max, intervals)")
x_l = float(x_max - x_min)
x_d = x_l/float(x_n)
x_a = arange(float(x_min), float(x_max)+x_d, x_d)
y_l = float(y_max - y_min)
y_d = y_l/float(y_n)
y_a = arange(float(y_min), float(y_max)+y_d, y_d)
def meshgrid(x, y):
"""
Taken from matplotlib.mlab.meshgrid.
"""
x = array(x)
y = array(y)
numRows, numCols = len(y), len(x)
x.shape = 1, numCols
X = repeat(x, numRows, 0)
y.shape = numRows, 1
Y = repeat(y, numCols, 1)
return X, Y
X, Y = meshgrid(x_a, y_a)
Z = ndarray((len(X), len(X[0])))
for j in range(len(X)):
for k in range(len(X[0])):
try:
Z[j][k] = float( f.subs(x, X[j][k]).subs(y, Y[j][k]) )
except:
Z[j][k] = 0
return X, Y, Z
def lambdastr(*args):
"""
>>> from sympy import symbols
>>> x,y,z = symbols('xyz')
>>> lambdastr(x**2, [x])
'lambda x: (x**2)'
>>> lambdastr([z,y,x], [x,y,z])
'lambda x,y,z: (z,y,x)'
"""
assert len(args) == 2
if isinstance(args[0], str) and isinstance(args[1], str):
exprs, vargs = args
elif isinstance(args[1], (list, tuple)):
vargs = args[1]
for v in vargs:
assert isinstance(v, Symbol)
if isinstance(args[0], (list, tuple)):
exprs = list(args[0])
else: exprs = [args[0]]
for e in xrange(len(exprs)):
exprs[e] = Basic.sympify(exprs[e])
for a in exprs[e].atoms(type=Symbol):
assert a in vargs
vargs = ','.join(str(v) for v in vargs)
exprs = ','.join(str(e) for e in exprs)
else: raise ValueError("Lambdification requires arguments "
"of the form expr(s), vars. Examples: "
"(x**2, [x]) or ([x**2, 1/y], [x,y]).")
return "lambda %s: (%s)" % (vargs, exprs)
def mathml(expr):
"""Returns the MathML representation of expr"""
s = MathMLPrinter()
return s.doprint(Basic.sympify(expr))