def test_diofant_parser():
x = Symbol('x')
inputs = {
'2*x':
2 * x,
'3.00':
Float(3),
'22/7':
Rational(22, 7),
'2+3j':
2 + 3 * I,
'exp(x)':
exp(x),
'-(2)':
-Integer(2),
'[-1, -2, 3]': [Integer(-1), Integer(-2),
Integer(3)],
'Symbol("x").free_symbols':
x.free_symbols,
'Float(Integer(3).evalf(3))':
3.00,
'factorint(12, visual=True)':
Mul(Pow(2, 2, evaluate=False),
Pow(3, 1, evaluate=False),
evaluate=False),
'Limit(sin(x), x, 0, dir="-")':
Limit(sin(x), x, 0, dir='-'),
}
for text, result in inputs.items():
assert parse_expr(text) == result
def test_sympyissue_4149():
assert (3 + I).is_complex
assert (3 + I).is_imaginary is False
assert (3 * I + S.Pi * I).is_imaginary
y = Symbol('y', real=True)
assert (3 * I + S.Pi * I + y * I).is_imaginary is True
p = Symbol('p', positive=True, finite=True)
assert (3 * I + S.Pi * I + p * I).is_imaginary
n = Symbol('n', negative=True, finite=True)
assert (-3 * I - S.Pi * I + n * I).is_imaginary
i = Symbol('i', imaginary=True)
assert ([(i**a).is_imaginary
for a in range(4)] == [False, True, False, True])
# tests from the PR sympy/sympy#7887:
e = -sqrt(3) * I / 2 + Float(0.866025403784439) * I
assert e.is_extended_real is False
assert e.is_imaginary
def test_ipython_printing(monkeypatch):
app = ipython.terminal.ipapp.TerminalIPythonApp()
app.display_banner = False
app.initialize([])
app = app.shell
app.run_cell("ip = get_ipython()")
app.run_cell("inst = ip.instance()")
app.run_cell("format = inst.display_formatter.format")
app.run_cell("import warnings")
app.run_cell("import IPython")
app.run_cell("import diofant")
app.run_cell("from diofant import Float, Rational, Symbol, QQ, "
"factorial, sqrt, init_printing, pretty, "
"Matrix, sstrrepr")
# Test IntegerDivisionWrapper
app.run_cell(
"from diofant.interactive.session import IntegerDivisionWrapper")
app.run_cell("ip.ast_transformers.clear()")
app.run_cell("ip.ast_transformers.append(IntegerDivisionWrapper())")
app.run_cell("a = 1")
assert isinstance(app.user_ns['a'], int)
app.run_cell("a = 1/2")
assert isinstance(app.user_ns['a'], Rational)
app.run_cell("a = 1")
assert isinstance(app.user_ns['a'], int)
app.run_cell("a = int(1)")
assert isinstance(app.user_ns['a'], int)
app.run_cell("a = (1/\n2)")
assert app.user_ns['a'] == Rational(1, 2)
# Test AutomaticSymbols
app.run_cell("from diofant.interactive.session import AutomaticSymbols")
app.run_cell("ip.ast_transformers.clear()")
app.run_cell("ip.ast_transformers.append(AutomaticSymbols())")
symbol = "verylongsymbolname"
assert symbol not in app.user_ns
app.run_cell("a = %s" % symbol)
app.run_cell("a = type(%s)" % symbol)
assert app.user_ns['a'] == Symbol
app.run_cell("%s = Symbol('%s')" % (symbol, symbol))
assert symbol in app.user_ns
# Check that built-in names aren't overridden
app.run_cell("a = all == __builtin__.all")
assert "all" not in app.user_ns
assert app.user_ns['a'] is True
# Check that diofant names aren't overridden
app.run_cell("a = factorial == diofant.factorial")
assert app.user_ns['a'] is True
# Test FloatRationalizer
app.run_cell("from diofant.interactive.session import FloatRationalizer")
app.run_cell("ip.ast_transformers.clear()")
app.run_cell("ip.ast_transformers.append(FloatRationalizer())")
app.run_cell("a = 0.3")
assert isinstance(app.user_ns['a'], Rational)
app.run_cell("a = float(0.3)")
assert isinstance(app.user_ns['a'], float)
app.run_cell("a = Float(1.23)")
assert isinstance(app.user_ns['a'], Float)
assert app.user_ns['a'] == Float(1.23)
app.run_cell("a = 2")
assert isinstance(app.user_ns['a'], int)
# General printing tests
# Initialize and setup IPython session
app.run_cell("ip.ast_transformers.clear()")
# Printing by default
app.run_cell("a = format(Symbol('pi'))")
app.run_cell("a2 = format(Symbol('pi')**2)")
app.run_cell("init_printing()")
assert app.user_ns['a'][0]['text/plain'] in ('\N{GREEK SMALL LETTER PI}',
'pi')
assert app.user_ns['a2'][0]['text/plain'] in (
' 2\n\N{GREEK SMALL LETTER PI} ', ' 2\npi ')
# Use different printing setup
app.run_cell("init_printing(use_unicode=False)")
app.run_cell("a = format(Symbol('pi'))")
app.run_cell("a2 = format(Symbol('pi')**2)")
assert app.user_ns['a'][0]['text/plain'] == "pi"
assert app.user_ns['a2'][0]['text/plain'] == " 2\npi "
app.run_cell("a = format(int(1))")
pytest.raises(KeyError, lambda: app.user_ns['a'][0]['text/latex'])
app.run_cell("init_printing()")
app.run_cell("a = format({Symbol('pi'): 3.14, Symbol('n_i'): 3})")
text = app.user_ns['a'][0]['text/plain']
pytest.raises(KeyError, lambda: app.user_ns['a'][0]['text/latex'])
# XXX: How can we make this ignore the terminal width? This test fails if
# the terminal is too narrow.
assert text in (
'{n\N{LATIN SUBSCRIPT SMALL LETTER I}: 3, \N{GREEK SMALL LETTER PI}: 3.14}',
'{\N{GREEK SMALL LETTER PI}: 3.14, n\N{LATIN SUBSCRIPT SMALL LETTER I}: 3}'
)
# If we enable the default printing, then the dictionary's should render
# as a LaTeX version of the whole dict: ${\pi: 3.14, n_i: 3}$
app.run_cell("init_printing()")
app.run_cell(
"inst.display_formatter.formatters['text/latex'].enabled = True")
app.run_cell("a = format({Symbol('pi'): 3.14, Symbol('n_i'): 3})")
text = app.user_ns['a'][0]['text/plain']
latex = app.user_ns['a'][0]['text/latex']
assert text in (
'{n\N{LATIN SUBSCRIPT SMALL LETTER I}: 3, \N{GREEK SMALL LETTER PI}: 3.14}',
'{\N{GREEK SMALL LETTER PI}: 3.14, n\N{LATIN SUBSCRIPT SMALL LETTER I}: 3}'
)
assert latex == r'\begin{equation*}\left \{ n_{i} : 3, \quad \pi : 3.14\right \}\end{equation*}'
app.run_cell("a = format([Symbol('x'), Symbol('y')])")
latex = app.user_ns['a'][0]['text/latex']
assert latex in (
r'\begin{equation*}\left [ x, \quad y\right ]\end{equation*}',
r'\begin{equation*}left [ y, \quad x\right ]\end{equation*}')
app.run_cell("a = format(False)")
assert app.user_ns['a'][0]['text/plain'] == r'False'
app.run_cell("init_printing(no_global=True)")
app.run_cell("a = format({Symbol('pi')})")
assert app.user_ns['a'][0]['text/plain'] == '{\N{GREEK SMALL LETTER PI}}'
app.run_cell("init_printing(use_unicode=False)")
app.run_cell("a = format(Symbol('pi'))")
assert app.user_ns['a'][0]['text/plain'] == 'pi'
app.run_cell("init_printing(order=None)") # this will fallback to defaults
app.run_cell("a = format(Symbol('pi'))")
assert app.user_ns['a'][0]['text/plain'] == 'π'
app.run_cell("init_printing()")
app.run_cell(
"inst.display_formatter.formatters['text/latex'].enabled = False")
app.run_cell("a = format({Symbol('pi'): 3.14, Symbol('n_i'): 3})")
text = app.user_ns['a'][0]['text/plain']
pytest.raises(KeyError, lambda: app.user_ns['a'][0]['text/latex'])
# something to test default pretty/latex printing
app.run_cell("init_printing()")
app.run_cell(
"inst.display_formatter.formatters['text/latex'].enabled = True")
app.run_cell("a = format(QQ.algebraic_field(sqrt(2)))")
text = app.user_ns['a'][0]['text/plain']
latex = app.user_ns['a'][0]['text/latex']
assert text == "QQ<sqrt(2)>"
assert latex == r"\begin{equation}QQ<sqrt(2)>\end{equation}"
# test_matplotlib_bad_latex
# Initialize and setup IPython session
app.run_cell("init_printing()")
# Make sure no warnings are raised by IPython
app.run_cell(
"warnings.simplefilter('error', IPython.core.formatters.FormatterWarning)"
)
# This should not raise an exception
app.run_cell("a = format(Matrix([1, 2, 3]))")
# Test dumb terminal
monkeypatch.setenv('TERM', '')
app.run_cell("init_printing()")
app.run_cell("a = format(Symbol('pi'))")
assert app.user_ns['a'][0]['text/plain'] == "pi"
def test_negative_real():
def feq(a, b):
return abs(a - b) < 1E-10
assert feq(S.One / Float(-0.5), -Integer(2))
def _eval_evalf(self, prec):
"""Evaluate this complex root to the given precision. """
with workprec(prec):
g = self.poly.gen
if not g.is_Symbol:
d = Dummy('x')
func = lambdify(d, self.expr.subs(g, d))
else:
func = lambdify(g, self.expr)
interval = self._get_interval()
if not self.is_extended_real:
# For complex intervals, we need to keep refining until the
# imaginary interval is disjunct with other roots, that is,
# until both ends get refined.
ay = interval.ay
by = interval.by
while interval.ay == ay or interval.by == by:
interval = interval.refine()
while True:
if self.is_extended_real:
a = mpf(str(interval.a))
b = mpf(str(interval.b))
if a == b:
root = a
break
x0 = mpf(str(interval.center))
else:
ax = mpf(str(interval.ax))
bx = mpf(str(interval.bx))
ay = mpf(str(interval.ay))
by = mpf(str(interval.by))
if ax == bx and ay == by:
# the sign of the imaginary part will be assigned
# according to the desired index using the fact that
# roots are sorted with negative imag parts coming
# before positive (and all imag roots coming after real
# roots)
deg = self.poly.degree()
i = self.index # a positive attribute after creation
if (deg - i) % 2:
if ay < 0:
ay = -ay
else:
if ay > 0:
ay = -ay
root = mpc(ax, ay)
break
x0 = mpc(*map(str, interval.center))
try:
root = findroot(func, x0)
# If the (real or complex) root is not in the 'interval',
# then keep refining the interval. This happens if findroot
# accidentally finds a different root outside of this
# interval because our initial estimate 'x0' was not close
# enough. It is also possible that the secant method will
# get trapped by a max/min in the interval; the root
# verification by findroot will raise a ValueError in this
# case and the interval will then be tightened -- and
# eventually the root will be found.
if self.is_extended_real:
if (a <= root <= b):
break
elif (ax <= root.real <= bx and ay <= root.imag <= by):
break
except ValueError:
pass
interval = interval.refine()
return Float._new(root.real._mpf_,
prec) + I * Float._new(root.imag._mpf_, prec)