def equation(self, x='x', y='y'):
"""The equation of the ellipse.
Parameters
----------
x : str, optional
Label for the x-axis. Default value is 'x'.
y : str, optional
Label for the y-axis. Default value is 'y'.
Returns
-------
equation : sympy expression
Examples
--------
>>> from sympy import Point, Ellipse
>>> e1 = Ellipse(Point(1, 0), 3, 2)
>>> e1.equation()
-1 + (1/3 - x/3)**2 + y**2/4
"""
if isinstance(x, basestring): x = C.Symbol(x, real=True)
if isinstance(y, basestring): y = C.Symbol(y, real=True)
t1 = ((x - self.center[0]) / self.hradius)**2
t2 = ((y - self.center[1]) / self.vradius)**2
return t1 + t2 - 1
def equation(self, x='x', y='y'):
"""The equation of the circle.
Parameters
----------
x : str or Symbol, optional
Default value is 'x'.
y : str or Symbol, optional
Default value is 'y'.
Returns
-------
equation : sympy expression
Examples
--------
>>> from sympy import Point, Circle
>>> c1 = Circle(Point(0, 0), 5)
>>> c1.equation()
-25 + x**2 + y**2
"""
if isinstance(x, basestring):
x = C.Symbol(x, real=True)
if isinstance(y, basestring):
y = C.Symbol(y, real=True)
t1 = (x - self.center[0])**2
t2 = (y - self.center[1])**2
return t1 + t2 - self.hradius**2
def equation(self, xaxis_name='x', yaxis_name='y'):
"""
Returns the equation for this line. Optional parameters xaxis_name
and yaxis_name can be used to specify the names of the symbols used
for the equation.
"""
x = C.Symbol(xaxis_name, real=True)
y = C.Symbol(yaxis_name, real=True)
a, b, c = self.coefficients
return simplify(a * x + b * y + c)
def equation(self, x='x', y='y'):
"""
Returns the equation of the circle.
Optional parameters x and y can be used to specify symbols, or the
names of the symbols used in the equation.
"""
if isinstance(x, basestring): x = C.Symbol(x, real=True)
if isinstance(y, basestring): y = C.Symbol(y, real=True)
t1 = (x - self.center[0])**2
t2 = (y - self.center[1])**2
return t1 + t2 - self.hradius**2
def __contains__(self, o):
"""Return True if o is on this Line, or False otherwise."""
if isinstance(o, Line):
return self.__eq__(o)
elif isinstance(o, Point):
x = C.Symbol('x', real=True)
y = C.Symbol('y', real=True)
r = self.equation().subs({x: o[0], y: o[1]})
x = simplify(r)
return simplify(x) == 0
else:
return False
def fdiff(self, argindex=1):
if argindex == 1:
return 1 / self.args[0]
s = C.Symbol('x', dummy=True)
return Lambda(s**(-1), s)
else:
raise ArgumentIndexError(self, argindex)
def arbitrary_point(self, parameter_name='t'):
"""A parametric point on the ellipse.
Parameters
----------
parameter_name : str, optional
Default value is 't'.
Returns
-------
arbitrary_point : Point
See Also
--------
Point
Examples
--------
>>> from sympy import Point, Ellipse
>>> e1 = Ellipse(Point(0, 0), 3, 2)
>>> e1.arbitrary_point()
Point(3*cos(t), 2*sin(t))
"""
t = C.Symbol(parameter_name, real=True)
return Point(self.center[0] + self.hradius * C.cos(t),
self.center[1] + self.vradius * C.sin(t))
def random_point(self):
"""Returns a random point on the ellipse."""
from random import random
t = C.Symbol('t', real=True)
p = self.arbitrary_point('t')
# get a random value in [-pi, pi)
subs_val = float(S.Pi) * (2 * random() - 1)
return Point(p[0].subs(t, subs_val), p[1].subs(t, subs_val))
def __init__(self, settings=None):
CodePrinter.__init__(self, settings)
self._init_leading_padding()
assign_to = self._settings['assign_to']
if isinstance(assign_to, string_types):
self._settings['assign_to'] = C.Symbol(assign_to)
elif not isinstance(assign_to, (C.Basic, type(None))):
raise TypeError("FCodePrinter cannot assign to object of type %s" %
type(assign_to))
def doprint(self, expr, assign_to=None):
"""
Print the expression as code.
Parameters
----------
expr : Expression
The expression to be printed.
assign_to : Symbol, MatrixSymbol, or string (optional)
If provided, the printed code will set the expression to a
variable with name ``assign_to``.
"""
if isinstance(assign_to, string_types):
assign_to = C.Symbol(assign_to)
elif not isinstance(assign_to, (C.Basic, type(None))):
raise TypeError("{0} cannot assign to object of type {1}".format(
type(self).__name__, type(assign_to)))
if assign_to:
expr = Assignment(assign_to, expr)
else:
expr = _sympify(expr)
# keep a set of expressions that are not strictly translatable to Code
# and number constants that must be declared and initialized
self._not_supported = set()
self._number_symbols = set()
lines = self._print(expr).splitlines()
# format the output
if self._settings["human"]:
frontlines = []
if len(self._not_supported) > 0:
frontlines.append(
self._get_comment("Not supported in {0}:".format(
self.language)))
for expr in sorted(self._not_supported, key=str):
frontlines.append(self._get_comment(type(expr).__name__))
for name, value in sorted(self._number_symbols, key=str):
frontlines.append(self._declare_number_const(name, value))
lines = frontlines + lines
lines = self._format_code(lines)
result = "\n".join(lines)
else:
lines = self._format_code(lines)
result = (self._number_symbols, self._not_supported,
"\n".join(lines))
del self._not_supported
del self._number_symbols
return result
def doprint(self, expr, assign_to=None):
"""
Actually format the expression as Javascript code.
"""
if isinstance(assign_to, basestring):
assign_to = C.Symbol(assign_to)
elif not isinstance(assign_to, (C.Basic, type(None))):
raise TypeError(
"JavascriptCodePrinter cannot assign to object of type %s" %
type(assign_to))
# keep a set of expressions that are not strictly translatable to Javascript
# and number constants that must be declared and initialized
not_js = self._not_supported = set()
self._number_symbols = set()
# We treat top level Piecewise here to get if tests outside loops
lines = []
if isinstance(expr, C.Piecewise):
for i, (e, c) in enumerate(expr.args):
if i == 0:
lines.append("if (%s) {" % self._print(c))
elif i == len(expr.args) - 1 and c is True:
lines.append("else {")
else:
lines.append("else if (%s) {" % self._print(c))
code0 = self._doprint_a_piece(e, assign_to)
lines.extend(code0)
lines.append("}")
else:
code0 = self._doprint_a_piece(expr, assign_to)
lines.extend(code0)
# format the output
if self._settings["human"]:
frontlines = []
if len(not_js) > 0:
frontlines.append("// Not Javascript:")
for expr in sorted(not_js, key=str):
frontlines.append("// %s" % repr(expr))
for name, value in sorted(self._number_symbols, key=str):
frontlines.append("var %s = %s;" % (name, value))
lines = frontlines + lines
lines = "\n".join(lines)
result = self.indent_code(lines)
else:
lines = self.indent_code("\n".join(lines))
result = self._number_symbols, not_js, lines
del self._not_supported
del self._number_symbols
return result
def _print_Function(self, e):
from sympy.physics.vector.functions import dynamicsymbols
t = dynamicsymbols._t
# XXX works only for applied functions
func = e.func
args = e.args
func_name = func.__name__
pform = self._print_Symbol(C.Symbol(func_name))
# If this function is an Undefined function of t, it is probably a
# dynamic symbol, so we'll skip the (t). The rest of the code is
# identical to the normal PrettyPrinter code
if not (isinstance(func, UndefinedFunction) and (args == (t,))):
return super(VectorPrettyPrinter, self)._print_Function(e)
return pform
def _print_Function(self, e):
# XXX works only for applied functions
func = e.func
args = e.args
n = len(args)
func_name = func.__name__
prettyFunc = self._print(C.Symbol(func_name));
prettyArgs = prettyForm(*self._print_seq(args).parens())
pform = prettyForm(binding=prettyForm.FUNC, *stringPict.next(prettyFunc, prettyArgs))
# store pform parts so it can be reassembled e.g. when powered
pform.prettyFunc = prettyFunc
pform.prettyArgs = prettyArgs
return pform
def _print_Lambda(self, e):
symbols, expr = e.args
if len(symbols) == 1:
symbols = self._print(symbols[0])
else:
symbols = self._print(tuple(symbols))
args = (symbols, self._print(expr))
prettyFunc = self._print(C.Symbol("Lambda"))
prettyArgs = prettyForm(*self._print_seq(args).parens())
pform = prettyForm(binding=prettyForm.FUNC, *stringPict.next(prettyFunc, prettyArgs))
# store pform parts so it can be reassembled e.g. when powered
pform.prettyFunc = prettyFunc
pform.prettyArgs = prettyArgs
return pform
def _print_Function(self, e):
from sympy.physics.vector.functions import dynamicsymbols
t = dynamicsymbols._t
# XXX works only for applied functions
func = e.func
args = e.args
func_name = func.__name__
prettyFunc = self._print(C.Symbol(func_name))
prettyArgs = prettyForm(*self._print_seq(args).parens())
# If this function is an Undefined function of t, it is probably a
# dynamic symbol, so we'll skip the (t). The rest of the code is
# identical to the normal PrettyPrinter code
if isinstance(func, UndefinedFunction) and (args == (t, )):
pform = prettyForm(binding=prettyForm.FUNC,
*stringPict.next(prettyFunc))
else:
pform = prettyForm(binding=prettyForm.FUNC,
*stringPict.next(prettyFunc, prettyArgs))
# store pform parts so it can be reassembled e.g. when powered
pform.prettyFunc = prettyFunc
pform.prettyArgs = prettyArgs
return pform
def random_point(self):
"""A random point on the ellipse.
Returns
-------
point : Point
See Also
--------
Point
Note
----
A random point may not appear to be on the ellipse, ie, `p in e` may
return False. This is because the coordinates of the point will be
floating point values, and when these values are substituted into the
equation for the ellipse the result may not be zero because of floating
point rounding error.
Examples
--------
>>> from sympy import Point, Ellipse
>>> e1 = Ellipse(Point(0, 0), 3, 2)
>>> p1 = e1.random_point()
>>> # a random point may not appear to be on the ellipse because of
>>> # floating point rounding error
>>> p1 in e1 # doctest: +SKIP
True
>>> p1 # doctest +ELLIPSIS
Point(...)
"""
from random import random
t = C.Symbol('t', real=True)
p = self.arbitrary_point('t')
# get a random value in [-pi, pi)
subs_val = float(S.Pi) * (2 * random() - 1)
return Point(p[0].subs(t, subs_val), p[1].subs(t, subs_val))
def plot_interval(self, parameter_name='t'):
"""The plot interval for the default geometric plot of the Ellipse.
Parameters
----------
parameter_name : str, optional
Default value is 't'.
Returns
-------
plot_interval : list
[parameter, lower_bound, upper_bound]
Examples
--------
>>> from sympy import Point, Ellipse
>>> e1 = Ellipse(Point(0, 0), 3, 2)
>>> e1.plot_interval()
[t, -pi, pi]
"""
t = C.Symbol(parameter_name, real=True)
return [t, -S.Pi, S.Pi]
def plot_interval(self, parameter_name='t'):
t = C.Symbol(parameter_name, real=True)
return [t, 0, 1]
def arbitrary_point(self, parameter_name='t'):
"""Returns a symbolic point that is on this line segment."""
t = C.Symbol(parameter_name, real=True)
x = simplify(self.p1[0] + t * (self.p2[0] - self.p1[0]))
y = simplify(self.p1[1] + t * (self.p2[1] - self.p1[1]))
return Point(x, y)
def plot_interval(self, parameter_name='t'):
"""Returns the plot interval for the default geometric plot of line"""
t = C.Symbol(parameter_name, real=True)
return [t, -5, 5]
def __new__(cls, expr, *symbols, **assumptions):
expr = sympify(expr).expand()
if expr is S.NaN:
return S.NaN
if symbols:
symbols = map(sympify, symbols)
else:
symbols = list(expr.atoms(C.Symbol))
symbols.sort(Basic.compare)
if expr.is_Order:
new_symbols = list(expr.symbols)
for s in symbols:
if s not in new_symbols:
new_symbols.append(s)
if len(new_symbols)==len(expr.symbols):
return expr
symbols = new_symbols
elif symbols:
symbol_map = {}
new_symbols = []
for s in symbols:
if isinstance(s, C.Symbol):
new_symbols.append(s)
continue
z = C.Symbol('z',dummy=True)
x1,s1 = solve4linearsymbol(s, z)
expr = expr.subs(x1,s1)
symbol_map[z] = s
new_symbols.append(z)
if symbol_map:
r = Order(expr, *new_symbols, **assumptions)
expr = r.expr.subs(symbol_map)
symbols = []
for s in r.symbols:
if symbol_map.has_key(s):
symbols.append(symbol_map[s])
else:
symbols.append(s)
else:
if expr.is_Add:
lst = expr.extract_leading_order(*symbols)
expr = C.Add(*[f.expr for (e,f) in lst])
else:
expr = expr.as_leading_term(*symbols)
coeff, terms = expr.as_coeff_terms()
if coeff is S.Zero:
return coeff
expr = C.Mul(*[t for t in terms if t.has(*symbols)])
elif expr is not S.Zero:
expr = S.One
if expr is S.Zero:
return expr
# create Order instance:
obj = Expr.__new__(cls, expr, *symbols, **assumptions)
return obj
def plot_interval(self, parameter_name='t'):
"""Returns a typical plot interval used by the plotting module."""
t = C.Symbol(parameter_name, real=True)
return [t, -S.Pi, S.Pi]
def arbitrary_point(self, parameter_name='t'):
"""Returns a symbolic point that is on the ellipse."""
t = C.Symbol(parameter_name, real=True)
return Point(self.center[0] + self.hradius * C.cos(t),
self.center[1] + self.vradius * C.sin(t))
