def find_period_sqrt(x, ITS_MAX=20):
#x = S(sqrt(x))
x = np.sqrt(x)
seq = array([], dtype=float64)
for its in arange(ITS_MAX):
# subtract the integer part
y = x - floor(x)
# put that into an array
seq = hstack(( seq, floor(x).n() ))
# take the inverse
x = 1/y
# boom, we have the sequence
seq = seq[1:]
l = len(seq)
# find out how periodic it is
for i in arange(0,10):
# repeat some sequence
tiled_array = tile(seq[:i-1], 10*l//i)
# make it the right len
tiled_array = tiled_array[:l]
# see if they're equal
if array_equal(tiled_array, seq):
length = len(seq[:i-1])
#print length
#break
return length
#print -1
return -1
def _eval_expand_func(self, **hints):
from sympy import exp, I, floor, Add, Poly, Dummy, exp_polar, unpolarify
z, s, a = self.args
if z == 1:
return zeta(s, a)
if s.is_Integer and s <= 0:
t = Dummy('t')
p = Poly((t + a)**(-s), t)
start = 1/(1 - t)
res = S(0)
for c in reversed(p.all_coeffs()):
res += c*start
start = t*start.diff(t)
return res.subs(t, z)
if a.is_Rational:
# See section 18 of
# Kelly B. Roach. Hypergeometric Function Representations.
# In: Proceedings of the 1997 International Symposium on Symbolic and
# Algebraic Computation, pages 205-211, New York, 1997. ACM.
# TODO should something be polarified here?
add = S(0)
mul = S(1)
# First reduce a to the interaval (0, 1]
if a > 1:
n = floor(a)
if n == a:
n -= 1
a -= n
mul = z**(-n)
add = Add(*[-z**(k - n)/(a + k)**s for k in xrange(n)])
elif a <= 0:
n = floor(-a) + 1
a += n
mul = z**n
add = Add(*[z**(n - 1 - k)/(a - k - 1)**s for k in xrange(n)])
m, n = S([a.p, a.q])
zet = exp_polar(2*pi*I/n)
root = z**(1/n)
return add + mul*n**(s - 1)*Add(
*[polylog(s, zet**k*root)._eval_expand_func(**hints)
/ (unpolarify(zet)**k*root)**m for k in xrange(n)])
# TODO use minpoly instead of ad-hoc methods when issue 2789 is fixed
if z.func is exp and (z.args[0]/(pi*I)).is_Rational or z in [-1, I, -I]:
# TODO reference?
if z == -1:
p, q = S([1, 2])
elif z == I:
p, q = S([1, 4])
elif z == -I:
p, q = S([-1, 4])
else:
arg = z.args[0]/(2*pi*I)
p, q = S([arg.p, arg.q])
return Add(*[exp(2*pi*I*k*p/q)/q**s*zeta(s, (k + a)/q)
for k in xrange(q)])
return lerchphi(z, s, a)
def round_afz(val, ndigits=0):
u"""Round using round-away-from-zero strategy for halfway cases.
Python 3+ implements round-half-even, and Python 2.7 has a random behaviour
from end user point of view (in fact, result depends on internal
representation in floating point arithmetic).
"""
ceil = math.ceil
floor = math.floor
val = float(val)
if isnan(val) or isinf(val):
return val
s = repr(val).rstrip('0')
if 'e' in s:
# XXX: implement round-away-from-zero in this case too.
return round(val, ndigits)
sep = s.find('.')
pos = sep + ndigits
if ndigits <= 0:
pos -= 1
# Skip dot if needed to reach next digit.
next_pos = (pos + 1 if pos + 1 != sep else pos + 2)
if next_pos < 0 or next_pos == 0 and s[next_pos] == '-':
return 0.
if len(s) <= next_pos:
# No need to round (no digit after).
return val
power = 10**ndigits
if s[next_pos] in '01234':
return (floor(val*power)/power if val > 0 else ceil(val*power)/power)
else:
return (ceil(val*power)/power if val > 0 else floor(val*power)/power)
def test_frac():
assert isinstance(frac(x), frac)
assert frac(oo) == AccumBounds(0, 1)
assert frac(-oo) == AccumBounds(0, 1)
assert frac(n) == 0
assert frac(nan) == nan
assert frac(Rational(4, 3)) == Rational(1, 3)
assert frac(-Rational(4, 3)) == Rational(2, 3)
r = Symbol('r', real=True)
assert frac(I*r) == I*frac(r)
assert frac(1 + I*r) == I*frac(r)
assert frac(0.5 + I*r) == 0.5 + I*frac(r)
assert frac(n + I*r) == I*frac(r)
assert frac(n + I*k) == 0
assert frac(x + I*x) == frac(x + I*x)
assert frac(x + I*n) == frac(x)
assert frac(x).rewrite(floor) == x - floor(x)
assert frac(x).rewrite(ceiling) == x + ceiling(-x)
assert frac(y).rewrite(floor).subs(y, pi) == frac(pi)
assert frac(y).rewrite(floor).subs(y, -E) == frac(-E)
assert frac(y).rewrite(ceiling).subs(y, -pi) == frac(-pi)
assert frac(y).rewrite(ceiling).subs(y, E) == frac(E)
assert Eq(frac(y), y - floor(y))
assert Eq(frac(y), y + ceiling(-y))
def rationalize(x, maxcoeff=10000):
"""
Helps identifying a rational number from a float (or mpmath.mpf) value by
using a continued fraction. The algorithm stops as soon as a large partial
quotient is detected (greater than 10000 by default).
Examples
========
>>> from sympy.concrete.guess import rationalize
>>> from mpmath import cos, pi
>>> rationalize(cos(pi/3))
1/2
>>> from mpmath import mpf
>>> rationalize(mpf("0.333333333333333"))
1/3
While the function is rather intended to help 'identifying' rational
values, it may be used in some cases for approximating real numbers.
(Though other functions may be more relevant in that case.)
>>> rationalize(pi, maxcoeff = 250)
355/113
See also
========
Several other methods can approximate a real number as a rational, like:
* fractions.Fraction.from_decimal
* fractions.Fraction.from_float
* mpmath.identify
* mpmath.pslq by using the following syntax: mpmath.pslq([x, 1])
* mpmath.findpoly by using the following syntax: mpmath.findpoly(x, 1)
* sympy.simplify.nsimplify (which is a more general function)
The main difference between the current function and all these variants is
that control focuses on magnitude of partial quotients here rather than on
global precision of the approximation. If the real is "known to be" a
rational number, the current function should be able to detect it correctly
with the default settings even when denominator is great (unless its
expansion contains unusually big partial quotients) which may occur
when studying sequences of increasing numbers. If the user cares more
on getting simple fractions, other methods may be more convenient.
"""
p0, p1 = 0, 1
q0, q1 = 1, 0
a = floor(x)
while a < maxcoeff or q1 == 0:
p = a * p1 + p0
q = a * q1 + q0
p0, p1 = p1, p
q0, q1 = q1, q
if x == a:
break
x = 1 / (x - a)
a = floor(x)
return sympify(p) / q
def test_dir():
assert abs(x).series(x, 0, dir="+") == x
assert abs(x).series(x, 0, dir="-") == -x
assert floor(x + 2).series(x, 0, dir='+') == 2
assert floor(x + 2).series(x, 0, dir='-') == 1
assert floor(x + 2.2).series(x, 0, dir='-') == 2
assert ceiling(x + 2.2).series(x, 0, dir='-') == 3
assert sin(x + y).series(x, 0, dir='-') == sin(x + y).series(x, 0, dir='+')
def rightshift(a, b):
if issig('rr', a, b):
return Real(int(sym.floor(a)) >> int(sym.floor(b)))
if issig('qr', a, b):
b = sym.floor(b)
return a[-b:] + a[:-b]
raise BadTypeCombinationError('rightshift', a, b)
def leftshift(a, b):
if issig('rr', a, b):
return Real(int(sym.floor(a)) << int(sym.floor(b)))
if issig('qr', a, b):
b = sym.floor(b)
return a[b:] + a[:b]
raise BadTypeCombinationError('leftshift', a, b)
def test_dir():
x = Symbol('x')
y = Symbol('y')
assert abs(x).series(x, 0, dir="+") == x
assert abs(x).series(x, 0, dir="-") == -x
assert floor(x+2).series(x,0,dir='+') == 2
assert floor(x+2).series(x,0,dir='-') == 1
assert floor(x+2.2).series(x,0,dir='-') == 2
assert sin(x+y).series(x,0,dir='-') == sin(x+y).series(x,0,dir='+')
def test_issue_8444_nonworkingtests():
x = symbols('x', real=True)
assert (x <= oo) == (x >= -oo) == True
x = symbols('x')
assert x >= floor(x)
assert (x < floor(x)) == False
assert x <= ceiling(x)
assert (x > ceiling(x)) == False
def test_issue_8444_workingtests():
x = symbols('x')
assert Gt(x, floor(x)) == Gt(x, floor(x), evaluate=False)
assert Ge(x, floor(x)) == Ge(x, floor(x), evaluate=False)
assert Lt(x, ceiling(x)) == Lt(x, ceiling(x), evaluate=False)
assert Le(x, ceiling(x)) == Le(x, ceiling(x), evaluate=False)
i = symbols('i', integer=True)
assert (i > floor(i)) == False
assert (i < ceiling(i)) == False
def length(P, Q, D):
"""
Returns the length of aperiodic part + length of periodic part of
continued fraction representation of (P + sqrt(D))/Q. It is important
to remember that this does NOT return the length of the periodic
part but the addition of the legths of the two parts as mentioned above.
Usage
=====
length(P, Q, D) -> P, Q and D are integers corresponding to the
continued fraction (P + sqrt(D))/Q.
Details
=======
``P`` corresponds to the P in the continued fraction, (P + sqrt(D))/ Q
``D`` corresponds to the D in the continued fraction, (P + sqrt(D))/ Q
``Q`` corresponds to the Q in the continued fraction, (P + sqrt(D))/ Q
Examples
========
>>> from sympy.solvers.diophantine import length
>>> length(-2 , 4, 5) # (-2 + sqrt(5))/4
3
>>> length(-5, 4, 17) # (-5 + sqrt(17))/4
4
"""
x = P + sqrt(D)
y = Q
x = sympify(x)
v, res = [], []
q = x/y
if q < 0:
v.append(q)
res.append(floor(q))
q = q - floor(q)
num, den = rad_rationalize(1, q)
q = num / den
while 1:
v.append(q)
a = int(q)
res.append(a)
if q == a:
return len(res)
num, den = rad_rationalize(1,(q - a))
q = num / den
if q in v:
return len(res)
def test_series():
x, y = symbols('x,y')
assert floor(x).nseries(x, y, 100) == floor(y)
assert ceiling(x).nseries(x, y, 100) == ceiling(y)
assert floor(x).nseries(x, pi, 100) == 3
assert ceiling(x).nseries(x, pi, 100) == 4
assert floor(x).nseries(x, 0, 100) == 0
assert ceiling(x).nseries(x, 0, 100) == 1
assert floor(-x).nseries(x, 0, 100) == -1
assert ceiling(-x).nseries(x, 0, 100) == 0
def test_dir():
x = Symbol("x")
y = Symbol("y")
assert abs(x).series(x, 0, dir="+") == x
assert abs(x).series(x, 0, dir="-") == -x
assert floor(x + 2).series(x, 0, dir="+") == 2
assert floor(x + 2).series(x, 0, dir="-") == 1
assert floor(x + 2.2).series(x, 0, dir="-") == 2
assert ceiling(x + 2.2).series(x, 0, dir="-") == 3
assert sin(x + y).series(x, 0, dir="-") == sin(x + y).series(x, 0, dir="+")
def test_upretty_floor():
assert upretty(floor(x)) == u'⌊x⌋'
u = upretty( floor(1 / (y - floor(x))) )
s = \
u"""\
⎢ 1 ⎥
⎢───────⎥
⎣y - ⌊x⌋⎦\
"""
assert u == s
def power(a, b):
if issig('rr', a, b):
return sym.Pow(a, b)
if issig('sr', a, b):
return [p + q for p, q in itertools.product(a, repeat=sym.floor(b))]
if issig('qr', a, b):
return [list(tup) for tup in itertools.product(a, repeat=sym.floor(b))]
raise BadTypeCombinationError('power', a, b)
def test_issue_8853():
p = Symbol('x', even=True, positive=True)
assert floor(-p - S.Half).is_even == False
assert floor(-p + S.Half).is_even == True
assert ceiling(p - S.Half).is_even == True
assert ceiling(p + S.Half).is_even == False
assert get_integer_part(S.Half, -1, {}, True) == (0, 0)
assert get_integer_part(S.Half, 1, {}, True) == (1, 0)
assert get_integer_part(-S.Half, -1, {}, True) == (-1, 0)
assert get_integer_part(-S.Half, 1, {}, True) == (0, 0)
def test_evalf_integer_parts():
a = floor(log(8)/log(2) - exp(-1000), evaluate=False)
b = floor(log(8)/log(2), evaluate=False)
raises(PrecisionExhausted, "a.evalf()")
assert a.evalf(chop=True) == 3
assert a.evalf(maxprec=500) == 2
raises(PrecisionExhausted, "b.evalf()")
raises(PrecisionExhausted, "b.evalf(maxprec=500)")
assert b.evalf(chop=True) == 3
assert int(floor(factorial(50)/E,evaluate=False).evalf()) == \
11188719610782480504630258070757734324011354208865721592720336800L
assert int(ceiling(factorial(50)/E,evaluate=False).evalf()) == \
11188719610782480504630258070757734324011354208865721592720336801L
assert int(floor((GoldenRatio**999 / sqrt(5) + Rational(1,2))).evalf(1000)) == fibonacci(999)
assert int(floor((GoldenRatio**1000 / sqrt(5) + Rational(1,2))).evalf(1000)) == fibonacci(1000)
def test_bng_rounding():
""" Test Ceiling and Floor match BNG implementation of rounding """
x_sym = sympy.symbols('x')
for x in (-1.5, -1, -0.5, 0, 0.5, 1.0, 1.5):
for expr in (sympy.ceiling(x_sym), sympy.floor(x_sym)):
assert expr.subs({'x': x}) == eval(
_bng_print(expr), {}, {'rint': _rint, 'x': x})
def test_latex_functions():
assert latex(exp(x)) == "$e^{x}$"
assert latex(exp(1) + exp(2)) == "$e + e^{2}$"
f = Function("f")
assert latex(f(x)) == "$\\operatorname{f}\\left(x\\right)$"
beta = Function("beta")
assert latex(beta(x)) == r"$\operatorname{beta}\left(x\right)$"
assert latex(sin(x)) == r"$\operatorname{sin}\left(x\right)$"
assert latex(sin(x), fold_func_brackets=True) == r"$\operatorname{sin}x$"
assert latex(sin(2 * x ** 2), fold_func_brackets=True) == r"$\operatorname{sin}2 x^{2}$"
assert latex(sin(x ** 2), fold_func_brackets=True) == r"$\operatorname{sin}x^{2}$"
assert latex(asin(x) ** 2) == r"$\operatorname{asin}^{2}\left(x\right)$"
assert latex(asin(x) ** 2, inv_trig_style="full") == r"$\operatorname{arcsin}^{2}\left(x\right)$"
assert latex(asin(x) ** 2, inv_trig_style="power") == r"$\operatorname{sin}^{-1}\left(x\right)^{2}$"
assert latex(asin(x ** 2), inv_trig_style="power", fold_func_brackets=True) == r"$\operatorname{sin}^{-1}x^{2}$"
assert latex(factorial(k)) == r"$k!$"
assert latex(factorial(-k)) == r"$\left(- k\right)!$"
assert latex(floor(x)) == r"$\lfloor{x}\rfloor$"
assert latex(ceiling(x)) == r"$\lceil{x}\rceil$"
assert latex(abs(x)) == r"$\lvert{x}\rvert$"
assert latex(re(x)) == r"$\Re{x}$"
assert latex(im(x)) == r"$\Im{x}$"
assert latex(conjugate(x)) == r"$\overline{x}$"
assert latex(gamma(x)) == r"$\operatorname{\Gamma}\left(x\right)$"
assert latex(Order(x)) == r"$\operatorname{\mathcal{O}}\left(x\right)$"
def test_evalf_integer_parts():
a = floor(log(8)/log(2) - exp(-1000), evaluate=False)
b = floor(log(8)/log(2), evaluate=False)
raises(PrecisionExhausted, "a.evalf()")
assert a.evalf(chop=True) == 3
assert a.evalf(maxn=500) == 2
assert b.evalf() == 3
# equals, as a fallback, can still fail but it might succeed as here
assert ceiling(10*(sin(1)**2 + cos(1)**2)) == 10
assert int(floor(factorial(50)/E,evaluate=False).evalf()) == \
11188719610782480504630258070757734324011354208865721592720336800L
assert int(ceiling(factorial(50)/E,evaluate=False).evalf()) == \
11188719610782480504630258070757734324011354208865721592720336801L
assert int(floor((GoldenRatio**999 / sqrt(5) + Rational(1,2))).evalf(1000)) == fibonacci(999)
assert int(floor((GoldenRatio**1000 / sqrt(5) + Rational(1,2))).evalf(1000)) == fibonacci(1000)
def test_uniformsum():
n = Symbol("n", integer=True)
_k = Symbol("k")
X = UniformSum('x', n)
assert density(X)(x) == (Sum((-1)**_k*(-_k + x)**(n - 1)
*binomial(n, _k), (_k, 0, floor(x)))/factorial(n - 1))
def test_latex_functions():
assert latex(exp(x)) == "$e^{x}$"
assert latex(exp(1)+exp(2)) == "$e + e^{2}$"
f = Function('f')
assert latex(f(x)) == '$\\operatorname{f}\\left(x\\right)$'
beta = Function('beta')
assert latex(beta(x)) == r"$\operatorname{beta}\left(x\right)$"
assert latex(sin(x)) == r"$\operatorname{sin}\left(x\right)$"
assert latex(sin(x), fold_func_brackets=True) == r"$\operatorname{sin}x$"
assert latex(sin(2*x**2), fold_func_brackets=True) == \
r"$\operatorname{sin}2 x^{2}$"
assert latex(factorial(k)) == r"$k!$"
assert latex(factorial(-k)) == r"$\left(- k\right)!$"
assert latex(floor(x)) == r"$\lfloor{x}\rfloor$"
assert latex(ceiling(x)) == r"$\lceil{x}\rceil$"
assert latex(abs(x)) == r"$\lvert{x}\rvert$"
assert latex(re(x)) == r"$\Re{x}$"
assert latex(im(x)) == r"$\Im{x}$"
assert latex(conjugate(x)) == r"$\overline{x}$"
assert latex(gamma(x)) == r"$\operatorname{\Gamma}\left(x\right)$"
assert latex(Order(x)) == r"$\operatorname{\mathcal{O}}\left(x\right)$"
def test_ansi_math1_codegen():
# not included: log10
from sympy import acos, asin, atan, ceiling, cos, cosh, floor, log, ln, \
sin, sinh, sqrt, tan, tanh, N
x = symbols('x')
name_expr = [
("test_fabs", abs(x)),
("test_acos", acos(x)),
("test_asin", asin(x)),
("test_atan", atan(x)),
("test_ceil", ceiling(x)),
("test_cos", cos(x)),
("test_cosh", cosh(x)),
("test_floor", floor(x)),
("test_log", log(x)),
("test_ln", ln(x)),
("test_sin", sin(x)),
("test_sinh", sinh(x)),
("test_sqrt", sqrt(x)),
("test_tan", tan(x)),
("test_tanh", tanh(x)),
]
numerical_tests = []
for name, expr in name_expr:
for xval in 0.2, 0.5, 0.8:
expected = N(expr.subs(x, xval))
numerical_tests.append((name, (xval,), expected, 1e-14))
run_cc_test("ansi_math1", name_expr, numerical_tests)
def test_intrinsic_math1_codegen():
# not included: log10
from sympy import acos, asin, atan, ceiling, cos, cosh, floor, log, ln, \
sin, sinh, sqrt, tan, tanh, N
x = symbols('x')
name_expr = [
("test_fabs", abs(x)),
("test_acos", acos(x)),
("test_asin", asin(x)),
("test_atan", atan(x)),
("test_cos", cos(x)),
("test_cosh", cosh(x)),
("test_log", log(x)),
("test_ln", ln(x)),
("test_sin", sin(x)),
("test_sinh", sinh(x)),
("test_sqrt", sqrt(x)),
("test_tan", tan(x)),
("test_tanh", tanh(x)),
]
numerical_tests = []
for name, expr in name_expr:
for xval in 0.2, 0.5, 0.8:
expected = N(expr.subs(x, xval))
numerical_tests.append((name, (xval,), expected, 1e-14))
for lang, commands in valid_lang_commands:
if lang == "C":
name_expr_C = [("test_floor", floor(x)), ("test_ceil", ceiling(x))]
else:
name_expr_C = []
run_test("intrinsic_math1", name_expr + name_expr_C, numerical_tests, lang, commands)
def test_floor_requires_robust_assumptions():
assert limit(floor(sin(x)), x, 0, "+") == 0
assert limit(floor(sin(x)), x, 0, "-") == -1
assert limit(floor(cos(x)), x, 0, "+") == 0
assert limit(floor(cos(x)), x, 0, "-") == 0
assert limit(floor(5 + sin(x)), x, 0, "+") == 5
assert limit(floor(5 + sin(x)), x, 0, "-") == 4
assert limit(floor(5 + cos(x)), x, 0, "+") == 5
assert limit(floor(5 + cos(x)), x, 0, "-") == 5
def less_than(a, b):
if issig('qr', a, b):
return a[:sym.floor(b)]
if issig('rr', a, b) or issig('ll', a, b) or issig('ss', a, b):
return Real(bool(a < b))
raise BadTypeCombinationError('less_than', a, b)
def greater_than(a, b):
if issig('qr', a, b):
return a[sym.floor(b):]
if issig('rr', a, b) or issig('ll', a, b) or issig('ss', a, b):
return Real(bool(a > b))
raise BadTypeCombinationError('greater_than', a, b)
def gridpoints(self):
if self.coordinates._data is None:
raise ValueError("No coordinates attached to this SparseFunction")
ret = []
for coords in self.coordinates.data._local:
ret.append(tuple(int(sympy.floor((c - o.data)/i.spacing.data)) for c, o, i in
zip(coords, self.grid.origin, self.grid.dimensions)))
return ret
def test_uniformsum():
n = Symbol("n", integer=True)
x = Symbol("x")
_k = Symbol("k")
X = UniformSum(n, symbol=x)
assert Density(X) == (Lambda(_x, Sum((-1)**_k*(-_k + _x)**(n - 1)
*binomial(n, _k), (_k, 0, floor(_x)))/factorial(n - 1)))
def test_issue9474():
mods = [None, 'math']
if numpy:
mods.append('numpy')
if mpmath:
mods.append('mpmath')
for mod in mods:
f = lambdify(x, S.One / x, modules=mod)
assert f(2) == 0.5
f = lambdify(x, floor(S.One / x), modules=mod)
assert f(2) == 0
for absfunc, modules in product([Abs, abs], mods):
f = lambdify(x, absfunc(x), modules=modules)
assert f(-1) == 1
assert f(1) == 1
assert f(3 + 4j) == 5
def test_uniformsum():
n = Symbol("n", integer=True)
_k = Dummy("k")
x = Symbol("x")
X = UniformSum('x', n)
res = Sum((-1)**_k*(-_k + x)**(n - 1)*binomial(n, _k), (_k, 0, floor(x)))/factorial(n - 1)
assert density(X)(x).dummy_eq(res)
#Tests set functions
assert X.pspace.domain.set == Interval(0, n)
#Tests the characteristic_function
assert characteristic_function(X)(x) == (-I*(exp(I*x) - 1)/x)**n
#Tests the moment_generating_function
assert moment_generating_function(X)(x) == ((exp(x) - 1)/x)**n
def _infer_Resize(self, node):
assert get_opset(
self.out_mp_) <= 10 # only support opset 10 Resize for now
scales = self._try_get_value(node, 1)
if scales is not None:
input_sympy_shape = self._get_sympy_shape(node, 0)
new_sympy_shape = [
sympy.simplify(sympy.floor(d * s))
for d, s in zip(input_sympy_shape, scales)
]
self._update_computed_dims(new_sympy_shape)
vi = self.known_vi_[node.output[0]]
vi.CopyFrom(
helper.make_tensor_value_info(
node.output[0],
self.known_vi_[node.input[0]].type.tensor_type.elem_type,
get_shape_from_sympy_shape(new_sympy_shape)))
def _next_raw(self, c, context):
n = len(context) + 1
# Check if the context can be found for this order model and what are
# its cumulative frequencies
context_row = self.get_row_by_words(context)
if context_row is None:
# Back off to a lower-order model or raise an exception
if n > 1:
return self._next_raw(c, context[1:])
else:
raise Exception("1-grams context table broken.")
else:
# Calculate the cumulative probabilities interval the next word must
# contain. Explanation of variables:
#
# cf - cumulative frequencies of the ngram [context + (w)]
# CF - cumulative frequencies of the ngram [context]
# c - cumulative probabilities of w with the given context
c1, c2 = c
CF1, CF2 = context_row
cf1 = floor(CF1 + c1 * (CF2 - CF1))
cf2 = ceiling(CF1 + c2 * (CF2 - CF1))
table = get_table_name(self.dataset, "{n}grams".format(**locals()))
self.cur.execute("""
SELECT
w{n}
FROM
{table}
WHERE
cf1 <= {cf1} AND cf2 >= {cf2}
LIMIT 1;
""".format(**locals())
)
ngram_row = self.cur.fetchone()
if ngram_row is None:
return None
else:
return ngram_row[0]
def test_frac():
assert isinstance(frac(x), frac)
assert frac(n) == 0
assert frac(nan) == nan
assert frac(Rational(4, 3)) == Rational(1, 3)
assert frac(-Rational(4, 3)) == Rational(2, 3)
r = Symbol('r', real=True)
assert frac(I * r) == I * frac(r)
assert frac(1 + I * r) == I * frac(r)
assert frac(0.5 + I * r) == 0.5 + I * frac(r)
assert frac(n + I * r) == I * frac(r)
assert frac(n + I * k) == 0
assert frac(x + I * x) == frac(x + I * x)
assert frac(x + I * n) == frac(x)
assert frac(x).rewrite(floor) == x - floor(x)
def _floor_div_nth_cf__end_v1(poly, q):
'''
it seems N(RootOf(...)) is too slow
I try to use refine_root instead.
'''
rs = real_roots(poly)
qt = max(rs)
Q = floor(qt)
upper = zero_upper_bound_of_positive_poly(poly)
ndigit = num_radix_digits(upper, 10)
Q = int(neval(Q, ndigit + 3))
assert Q >= 1
assert not poly.subs(q, Q) > 0
assert not poly.subs(q, Q + 1) <= 0
return Q
def apply_grover(oracle, nqubits, iterations=None):
"""Applies grover's algorithm.
Parameters
==========
oracle : callable
The unknown callable function that returns true when applied to the
desired qubits and false otherwise.
Returns
=======
state : Expr
The resulting state after Grover's algorithm has been iterated.
Examples
========
Apply grover's algorithm to an even superposition of 2 qubits::
>>> from sympy.physics.quantum.qapply import qapply
>>> from sympy.physics.quantum.qubit import IntQubit
>>> from sympy.physics.quantum.grover import apply_grover
>>> f = lambda qubits: qubits == IntQubit(2)
>>> qapply(apply_grover(f, 2))
|2>
"""
if nqubits <= 0:
raise QuantumError(
'Grover\'s algorithm needs nqubits > 0, received %r qubits'
% nqubits
)
if iterations is None:
iterations = floor(sqrt(2**nqubits)*(pi/4))
v = OracleGate(nqubits, oracle)
iterated = superposition_basis(nqubits)
for iter in range(iterations):
iterated = grover_iteration(iterated, v)
iterated = qapply(iterated)
return iterated
def render_BinOp(self, node):
op_name = node.op.__class__.__name__
# Sympy implements division and subtraction as multiplication/addition
if op_name == 'Div':
op = self.expression_ops['Mult']
return op(self.render_node(node.left),
1 / self.render_node(node.right))
elif op_name == 'FloorDiv':
op = self.expression_ops['Mult']
left = self.render_node(node.left)
right = self.render_node(node.right)
return sympy.floor(op(left, 1 / right))
elif op_name == 'Sub':
op = self.expression_ops['Add']
return op(self.render_node(node.left),
-self.render_node(node.right))
else:
op = self.expression_ops[op_name]
return op(self.render_node(node.left), self.render_node(node.right))
def test_issue9474():
mods = [None, 'math']
if numpy:
mods.append('numpy')
if mpmath:
mods.append('mpmath')
for mod in mods:
f = lambdify(x, sympy.S(1) / x, modules=mod)
assert f(2) == 0.5
f = lambdify(x, floor(sympy.S(1) / x), modules=mod)
assert f(2) == 0
if mpmath:
f = lambdify(x, sympy.S(1) / sympy.Abs(x), modules=['mpmath'])
assert isinstance(f(2), mpmath.mpf)
for absfunc, modules in product([Abs, abs], mods):
f = lambdify(x, absfunc(x), modules=modules)
assert f(-1) == 1
assert f(1) == 1
assert f(3 + 4j) == 5
def premRSA():
n = int(
'0x6c451672f63e8ece9c3bde03f4483ed3d0e286c908a55b78e2d235021d95f4ba403e6cbaf14d15928867bb14ac855d7fbdc6ebbf99f151ab49832e70fdd19e8d29dfc4c4ca7329564a1d4182c1b02ef040d7e347e13db768203319357abe07b1ecaf5d099d3326d2639e0a5991ded8cb46b825709e0942e67f770520c26306e5f44c8ca72313106ff0dd9a90294edaa7e0097997ff2425c266e1d52c6935799a8cf7ebf12f88edd1dc683ffd252facf7fb3e9bca0467ebbb1dbe731e7ff9b245a78ca50e8f810202eef4e44ea0c01443584baf727b13aa2ba8978445345981a264fb15709f7b71b9611e0ef3f0b69c6a3ba9f12ea703bf742b3aa3fc1522d8d20466223bdfe5c2cc726d66a1416bcb26cab2976a915e6646143500e012896f355dea77e10a7ec36aacd547f66bf543a7d7841acbcd4f54ec267ad185984ef74a995ad7c141fa34f46956bb3d66db54c5f8f84252800d968cb1bd47b30030f3c54c8d45b2ed9e1809ae7aad3367a7d3b11c80539282b3deaa8e23bda567e09b87f33a60666e9247cc38c0d09666346d54e18fcd58e987fcfc1796ad4bc0cb498d5e100d640abdbdfcb45039464fe023679ad70fce916a5adffcb58520a22bbf1870cfe5fcbf651a30ace03a716b2a283bfaa076330abd502e1460f2182e64b565c3c1b3a77312fe98e77dd1b8eca1f80fe11d6f2675f9ea90cc533abd507dc285',
0)
e = int('0x10001', 0)
d0 = int(
'0xa5cb79ef8059485d8ee47a9da0ed128ea83febf509c009aafcada53d35b28a7b020f7308078257aae306052f2086fa89ad9c810a4fd9afe498825bdc16b3050e6e26c2ebcc49de22ab34c09e53a699f29252adc01c1a3c036f192105154d94858bbaf42bf1dfadc0cdf7338c5c9e9fdf9c508bdc9d260df831b781e5ce33b874999ebb0f07d72bbe6d0971a2164b660e1d3df4cb265e8edbc63ec56c2b05ce2eb32cf9808931a3968f1045c38ea022bfd750c3925073d1c5befec2268efe0bd047f2411f081aee2b71c443c5fd26fed6a75c9e31b89dfd93180215eaa51117bcf4be54f140fc39322c5deb32ae1ec164f4ae451a1391d7b612645c06cdf83541',
0)
c = int(
'0x36e7437512d71ca2a412fa411f7d376feaf02db7a6c301284ed9dc7dcffa8a658c24d199aa14d008ed72a88e36e2c5520caf95c88e5deb0d311d4fe2641732455bde7bc1c64a7274bcbe3825cd59b66727354fbbd01ab4ea39dbddd765395fa9c653556987f2f7efbdf86e741573338699e7fb7ad8405eeb02bc8fbca39a55870255328fcd44998bb5339805298575c0aef9bcfe791e8330bac92cd11620ad837ac2f7e9fcc4bf61da3c09cb8455e6d46890d5beb0b1af0bf989c10c6d83604de862bbb82fc697c2513488a9e3321d2590e9f5c0eb4a1882aa26c455da6e45f1fff42e233208ebd494365e89fb8e1ae89ea5b2f800e07b9e6b362bf4caaec11e81a8fc04377a7820f1392057f44bcbac03e9846b29989106e0dcf98559af1d5221aea01dd0d64667eb6615f7cce13e004249f2a0ccf065044450c1bd6661a986a53c983bf810d961f5c0a551fa66a08cf6cabf4e08291f1a08c7ee73c3b7c51a6d1620c9005530b8c1ce883eae095b1949eb4df159a35c7ce654cfc18527f08c8483d3630803bd688040a4b4bae86766f5535421bb8ec9c6e071b280f9e0db26c1cc90b56dba1cd09adeb520a996d6fd6ce135edb9e496986770cff49abc68473edc51ce0c79db915aae4ce1bb6fd42adb62b6b350cb84d37c52f30fe1e4943babf868bed50fa912ca431500ecb18643bb3df560450f673769818fdc48cdcdf6',
0)
bitLenN = int(sp.floor(sp.log(n) / sp.log(2)) + 1)
bitLenD0 = 2048
assert bitLenD0 >= bitLenN / 2
d = halfdPartialKeyRecoveryAttack(d0, 2048, 4096, n, e)
c = pow(c, d, n)
plaintext = str(bytearray.fromhex(hex(c)[2:]), 'utf-8')
print(plaintext)
def test_latex_functions():
assert latex(exp(x)) == "e^{x}"
assert latex(exp(1)+exp(2)) == "e + e^{2}"
f = Function('f')
assert latex(f(x)) == '\\operatorname{f}\\left(x\\right)'
beta = Function('beta')
assert latex(beta(x)) == r"\operatorname{beta}\left(x\right)"
assert latex(sin(x)) == r"\operatorname{sin}\left(x\right)"
assert latex(sin(x), fold_func_brackets=True) == r"\operatorname{sin}x"
assert latex(sin(2*x**2), fold_func_brackets=True) == \
r"\operatorname{sin}2 x^{2}"
assert latex(sin(x**2), fold_func_brackets=True) == \
r"\operatorname{sin}x^{2}"
assert latex(asin(x)**2) == r"\operatorname{asin}^{2}\left(x\right)"
assert latex(asin(x)**2,inv_trig_style="full") == \
r"\operatorname{arcsin}^{2}\left(x\right)"
assert latex(asin(x)**2,inv_trig_style="power") == \
r"\operatorname{sin}^{-1}\left(x\right)^{2}"
assert latex(asin(x**2),inv_trig_style="power",fold_func_brackets=True) == \
r"\operatorname{sin}^{-1}x^{2}"
assert latex(factorial(k)) == r"k!"
assert latex(factorial(-k)) == r"\left(- k\right)!"
assert latex(floor(x)) == r"\lfloor{x}\rfloor"
assert latex(ceiling(x)) == r"\lceil{x}\rceil"
assert latex(Abs(x)) == r"\lvert{x}\rvert"
assert latex(re(x)) == r"\Re{x}"
assert latex(im(x)) == r"\Im{x}"
assert latex(conjugate(x)) == r"\overline{x}"
assert latex(gamma(x)) == r"\operatorname{\Gamma}\left(x\right)"
assert latex(Order(x)) == r"\operatorname{\mathcal{O}}\left(x\right)"
assert latex(lowergamma(x, y)) == r'\operatorname{\gamma}\left(x, y\right)'
assert latex(uppergamma(x, y)) == r'\operatorname{\Gamma}\left(x, y\right)'
def test_symbolic_Range():
n = Symbol('n')
raises(ValueError, lambda: Range(n)[0])
raises(IndexError, lambda: Range(n, n)[0])
raises(ValueError, lambda: Range(n, n+1)[0])
raises(ValueError, lambda: Range(n).size)
n = Symbol('n', integer=True)
raises(ValueError, lambda: Range(n)[0])
raises(IndexError, lambda: Range(n, n)[0])
assert Range(n, n+1)[0] == n
raises(ValueError, lambda: Range(n).size)
assert Range(n, n+1).size == 1
n = Symbol('n', integer=True, nonnegative=True)
raises(ValueError, lambda: Range(n)[0])
raises(IndexError, lambda: Range(n, n)[0])
assert Range(n+1)[0] == 0
assert Range(n, n+1)[0] == n
assert Range(n).size == n
assert Range(n+1).size == n+1
assert Range(n, n+1).size == 1
n = Symbol('n', integer=True, positive=True)
assert Range(n)[0] == 0
assert Range(n, n+1)[0] == n
assert Range(n).size == n
assert Range(n, n+1).size == 1
m = Symbol('m', integer=True, positive=True)
assert Range(n, n+m)[0] == n
assert Range(n, n+m).size == m
assert Range(n, n+1).size == 1
assert Range(n, n+m, 2).size == floor(m/2)
m = Symbol('m', integer=True, positive=True, even=True)
assert Range(n, n+m, 2).size == m/2
def test_bng_printer():
# Constants
assert _bng_print(sympy.pi) == '_pi'
assert _bng_print(sympy.E) == '_e'
x, y = sympy.symbols('x y')
# Binary functions
assert _bng_print(sympy.sympify('x & y')) == 'x && y'
assert _bng_print(sympy.sympify('x | y')) == 'x || y'
# Trig functions
assert _bng_print(sympy.sin(x)) == 'sin(x)'
assert _bng_print(sympy.cos(x)) == 'cos(x)'
assert _bng_print(sympy.tan(x)) == 'tan(x)'
assert _bng_print(sympy.asin(x)) == 'asin(x)'
assert _bng_print(sympy.acos(x)) == 'acos(x)'
assert _bng_print(sympy.atan(x)) == 'atan(x)'
assert _bng_print(sympy.sinh(x)) == 'sinh(x)'
assert _bng_print(sympy.cosh(x)) == 'cosh(x)'
assert _bng_print(sympy.tanh(x)) == 'tanh(x)'
assert _bng_print(sympy.asinh(x)) == 'asinh(x)'
assert _bng_print(sympy.acosh(x)) == 'acosh(x)'
assert _bng_print(sympy.atanh(x)) == 'atanh(x)'
# Logs and powers
assert _bng_print(sympy.log(x)) == 'ln(x)'
assert _bng_print(sympy.exp(x)) == 'exp(x)'
assert _bng_print(sympy.sqrt(x)) == 'sqrt(x)'
# Rounding
assert _bng_print(sympy.Abs(x)) == 'abs(x)'
assert _bng_print(sympy.floor(x)) == 'rint(x - 0.5)'
assert _bng_print(sympy.ceiling(x)) == '(rint(x + 1) - 1)'
# Min/max
assert _bng_print(sympy.Min(x, y)) == 'min(x, y)'
assert _bng_print(sympy.Max(x, y)) == 'max(x, y)'
def test_naturals():
N = S.Naturals
assert 5 in N
assert -5 not in N
assert 5.5 not in N
ni = iter(N)
a, b, c, d = next(ni), next(ni), next(ni), next(ni)
assert (a, b, c, d) == (1, 2, 3, 4)
assert isinstance(a, Basic)
assert N.intersect(Interval(-5, 5)) == Range(1, 6)
assert N.intersect(Interval(-5, 5, True, True)) == Range(1, 5)
assert N.boundary == N
assert N.inf == 1
assert N.sup is oo
assert not N.contains(oo)
for s in (S.Naturals0, S.Naturals):
assert s.intersection(S.Reals) is s
assert s.is_subset(S.Reals)
assert N.as_relational(x) == And(Eq(floor(x), x), x >= 1, x < oo)
def test_integers():
Z = S.Integers
assert 5 in Z
assert -5 in Z
assert 5.5 not in Z
assert not Z.contains(oo)
assert not Z.contains(-oo)
zi = iter(Z)
a, b, c, d = next(zi), next(zi), next(zi), next(zi)
assert (a, b, c, d) == (0, 1, -1, 2)
assert isinstance(a, Basic)
assert Z.intersect(Interval(-5, 5)) == Range(-5, 6)
assert Z.intersect(Interval(-5, 5, True, True)) == Range(-4, 5)
assert Z.intersect(Interval(5, S.Infinity)) == Range(5, S.Infinity)
assert Z.intersect(Interval.Lopen(5, S.Infinity)) == Range(6, S.Infinity)
assert Z.inf is -oo
assert Z.sup is oo
assert Z.boundary == Z
assert Z.as_relational(x) == And(Eq(floor(x), x), -oo < x, x < oo)
def test_latex_functions():
assert latex(exp(x)) == "$e^{x}$"
assert latex(exp(1) + exp(2)) == "$e + e^{2}$"
f = Function('f')
assert latex(f(x)) == '$\\operatorname{f}\\left(x\\right)$'
beta = Function('beta')
assert latex(beta(x)) == r"$\operatorname{beta}\left(x\right)$"
assert latex(sin(x)) == r"$\operatorname{sin}\left(x\right)$"
assert latex(sin(x), fold_func_brackets=True) == r"$\operatorname{sin}x$"
assert latex(sin(2*x**2), fold_func_brackets=True) == \
r"$\operatorname{sin}2 x^{2}$"
assert latex(sin(x**2), fold_func_brackets=True) == \
r"$\operatorname{sin}x^{2}$"
assert latex(asin(x)**2) == r"$\operatorname{asin}^{2}\left(x\right)$"
assert latex(asin(x)**2,inv_trig_style="full") == \
r"$\operatorname{arcsin}^{2}\left(x\right)$"
assert latex(asin(x)**2,inv_trig_style="power") == \
r"$\operatorname{sin}^{-1}\left(x\right)^{2}$"
assert latex(asin(x**2),inv_trig_style="power",fold_func_brackets=True) == \
r"$\operatorname{sin}^{-1}x^{2}$"
assert latex(factorial(k)) == r"$k!$"
assert latex(factorial(-k)) == r"$\left(- k\right)!$"
assert latex(floor(x)) == r"$\lfloor{x}\rfloor$"
assert latex(ceiling(x)) == r"$\lceil{x}\rceil$"
assert latex(abs(x)) == r"$\lvert{x}\rvert$"
assert latex(re(x)) == r"$\Re{x}$"
assert latex(im(x)) == r"$\Im{x}$"
assert latex(conjugate(x)) == r"$\overline{x}$"
assert latex(gamma(x)) == r"$\operatorname{\Gamma}\left(x\right)$"
assert latex(Order(x)) == r"$\operatorname{\mathcal{O}}\left(x\right)$"
def test_issue_4149():
assert floor(3 + pi * I + y * I) == 3 + floor(pi + y) * I
assert floor(3 * I + pi * I + y * I) == floor(3 + pi + y) * I
assert floor(3 + E + pi * I + y * I) == 5 + floor(pi + y) * I
def test_floor():
assert floor(nan) == nan
assert floor(oo) == oo
assert floor(-oo) == -oo
assert floor(0) == 0
assert floor(1) == 1
assert floor(-1) == -1
assert floor(E) == 2
assert floor(-E) == -3
assert floor(2 * E) == 5
assert floor(-2 * E) == -6
assert floor(pi) == 3
assert floor(-pi) == -4
assert floor(Rational(1, 2)) == 0
assert floor(-Rational(1, 2)) == -1
assert floor(Rational(7, 3)) == 2
assert floor(-Rational(7, 3)) == -3
assert floor(Float(17.0)) == 17
assert floor(-Float(17.0)) == -17
assert floor(Float(7.69)) == 7
assert floor(-Float(7.69)) == -8
assert floor(I) == I
assert floor(-I) == -I
e = floor(i)
assert e.func is floor and e.args[0] == i
assert floor(oo * I) == oo * I
assert floor(-oo * I) == -oo * I
assert floor(2 * I) == 2 * I
assert floor(-2 * I) == -2 * I
assert floor(I / 2) == 0
assert floor(-I / 2) == -I
assert floor(E + 17) == 19
assert floor(pi + 2) == 5
assert floor(E + pi) == floor(E + pi)
assert floor(I + pi) == floor(I + pi)
assert floor(floor(pi)) == 3
assert floor(floor(y)) == floor(y)
assert floor(floor(x)) == floor(floor(x))
assert floor(x) == floor(x)
assert floor(2 * x) == floor(2 * x)
assert floor(k * x) == floor(k * x)
assert floor(k) == k
assert floor(2 * k) == 2 * k
assert floor(k * n) == k * n
assert floor(k / 2) == floor(k / 2)
assert floor(x + y) == floor(x + y)
assert floor(x + 3) == floor(x + 3)
assert floor(x + k) == floor(x + k)
assert floor(y + 3) == floor(y) + 3
assert floor(y + k) == floor(y) + k
assert floor(3 + I * y + pi) == 6 + floor(y) * I
assert floor(k + n) == k + n
assert floor(x * I) == floor(x * I)
assert floor(k * I) == k * I
assert floor(Rational(23, 10) - E * I) == 2 - 3 * I
assert floor(sin(1)) == 0
assert floor(sin(-1)) == -1
assert floor(exp(2)) == 7
assert floor(log(8) / log(2)) != 2
assert int(floor(log(8) / log(2)).evalf(chop=True)) == 3
assert floor(factorial(50)/exp(1)) == \
11188719610782480504630258070757734324011354208865721592720336800
assert (floor(y) <= y) == True
assert (floor(y) > y) == False
assert (floor(x) <= x).is_Relational # x could be non-real
assert (floor(x) > x).is_Relational
assert (floor(x) <= y).is_Relational # arg is not same as rhs
assert (floor(x) > y).is_Relational
import sympy.physics.mechanics as _me
import sympy as _sm
import math as m
import numpy as _np
x, y = _me.dynamicsymbols('x y')
x_d, y_d = _me.dynamicsymbols('x_ y_', 1)
e = _sm.cos(x)+_sm.sin(x)+_sm.tan(x)+_sm.cosh(x)+_sm.sinh(x)+_sm.tanh(x)+_sm.acos(x)+_sm.asin(x)+_sm.atan(x)+_sm.log(x)+_sm.exp(x)+_sm.sqrt(x)+_sm.factorial(x)+_sm.ceiling(x)+_sm.floor(x)+_sm.sign(x)
e = (x)**2+_sm.log(x, 10)
a = _sm.Abs(-1*1)+int(1.5)+round(1.9)
e1 = 2*x+3*y
e2 = x+y
am = _sm.Matrix([e1.expand().coeff(x), e1.expand().coeff(y), e2.expand().coeff(x), e2.expand().coeff(y)]).reshape(2, 2)
b = (e1).expand().coeff(x)
c = (e2).expand().coeff(y)
d1 = (e1).collect(x).coeff(x,0)
d2 = (e1).collect(x).coeff(x,1)
fm = _sm.Matrix([i.collect(x)for i in _sm.Matrix([e1,e2]).reshape(1, 2)]).reshape((_sm.Matrix([e1,e2]).reshape(1, 2)).shape[0], (_sm.Matrix([e1,e2]).reshape(1, 2)).shape[1])
f = (e1).collect(y)
g = (e1).subs({x:2*x})
gm = _sm.Matrix([i.subs({x:3}) for i in _sm.Matrix([e1,e2]).reshape(2, 1)]).reshape((_sm.Matrix([e1,e2]).reshape(2, 1)).shape[0], (_sm.Matrix([e1,e2]).reshape(2, 1)).shape[1])
frame_a = _me.ReferenceFrame('a')
frame_b = _me.ReferenceFrame('b')
theta = _me.dynamicsymbols('theta')
frame_b.orient(frame_a, 'Axis', [theta, frame_a.z])
v1 = 2*frame_a.x-3*frame_a.y+frame_a.z
v2 = frame_b.x+frame_b.y+frame_b.z
a = _me.dot(v1, v2)
bm = _sm.Matrix([_me.dot(v1, v2),_me.dot(v1, 2*v2)]).reshape(2, 1)
c = _me.cross(v1, v2)
d = 2*v1.magnitude()+3*v1.magnitude()
def test_floor():
assert limit(floor(x), x, -2, "+") == -2
assert limit(floor(x), x, -2, "-") == -3
assert limit(floor(x), x, -1, "+") == -1
assert limit(floor(x), x, -1, "-") == -2
assert limit(floor(x), x, 0, "+") == 0
assert limit(floor(x), x, 0, "-") == -1
assert limit(floor(x), x, 1, "+") == 1
assert limit(floor(x), x, 1, "-") == 0
assert limit(floor(x), x, 2, "+") == 2
assert limit(floor(x), x, 2, "-") == 1
assert limit(floor(x), x, 248, "+") == 248
assert limit(floor(x), x, 248, "-") == 247
def _eval_expand_func(self, **hints):
from sympy import exp, I, floor, Add, Poly, Dummy, exp_polar, unpolarify
z, s, a = self.args
if z == 1:
return zeta(s, a)
if s.is_Integer and s <= 0:
t = Dummy("t")
p = Poly((t + a) ** (-s), t)
start = 1 / (1 - t)
res = S.Zero
for c in reversed(p.all_coeffs()):
res += c * start
start = t * start.diff(t)
return res.subs(t, z)
if a.is_Rational:
# See section 18 of
# Kelly B. Roach. Hypergeometric Function Representations.
# In: Proceedings of the 1997 International Symposium on Symbolic and
# Algebraic Computation, pages 205-211, New York, 1997. ACM.
# TODO should something be polarified here?
add = S.Zero
mul = S.One
# First reduce a to the interaval (0, 1]
if a > 1:
n = floor(a)
if n == a:
n -= 1
a -= n
mul = z ** (-n)
add = Add(*[-(z ** (k - n)) / (a + k) ** s for k in range(n)])
elif a <= 0:
n = floor(-a) + 1
a += n
mul = z ** n
add = Add(*[z ** (n - 1 - k) / (a - k - 1) ** s for k in range(n)])
m, n = S([a.p, a.q])
zet = exp_polar(2 * pi * I / n)
root = z ** (1 / n)
return add + mul * n ** (s - 1) * Add(
*[
polylog(s, zet ** k * root)._eval_expand_func(**hints)
/ (unpolarify(zet) ** k * root) ** m
for k in range(n)
]
)
# TODO use minpoly instead of ad-hoc methods when issue 5888 is fixed
if (
isinstance(z, exp)
and (z.args[0] / (pi * I)).is_Rational
or z in [-1, I, -I]
):
# TODO reference?
if z == -1:
p, q = S([1, 2])
elif z == I:
p, q = S([1, 4])
elif z == -I:
p, q = S([-1, 4])
else:
arg = z.args[0] / (2 * pi * I)
p, q = S([arg.p, arg.q])
return Add(
*[
exp(2 * pi * I * k * p / q) / q ** s * zeta(s, (k + a) / q)
for k in range(q)
]
)
return lerchphi(z, s, a)
def test_floor():
x = Symbol("x")
e1 = sympy.floor(sympy.Symbol("x"))
e2 = floor(x)
assert sympify(e1) == e2
assert e2._sympy_() == e1
def LP(P, b):
return sp.integrate(P, (x, 0, sp.floor((b + 1) / 4))).evalf()
def sympy_intdiv_fix(expr):
""" Fix for SymPy printing out reciprocal values when they should be
integral in "ceiling/floor" sympy functions.
"""
nexpr = expr
if not isinstance(expr, sympy.Basic):
return expr
# The properties avoid matching the silly case "ceiling(N/32)" as
# ceiling of 1/N and 1/32
a = sympy.Wild('a', properties=[lambda k: k.is_Symbol or k.is_Integer])
b = sympy.Wild('b', properties=[lambda k: k.is_Symbol or k.is_Integer])
c = sympy.Wild('c')
d = sympy.Wild('d')
int_ceil = sympy.Function('int_ceil')
int_floor = sympy.Function('int_floor')
processed = 1
while processed > 0:
processed = 0
for ceil in nexpr.find(sympy.ceiling):
# Simple ceiling
m = ceil.match(sympy.ceiling(a / b))
if m is not None:
nexpr = nexpr.subs(ceil, int_ceil(m[a], m[b]))
processed += 1
continue
# Ceiling of ceiling: "ceil(ceil(c/d) / b)"
m = ceil.match(sympy.ceiling(int_ceil(c, d) / b))
if m is not None:
nexpr = nexpr.subs(ceil, int_ceil(int_ceil(m[c], m[d]), m[b]))
processed += 1
continue
# Ceiling of ceiling: "ceil(a / ceil(c/d))"
m = ceil.match(sympy.ceiling(a / int_ceil(c, d)))
if m is not None:
nexpr = nexpr.subs(ceil, int_ceil(m[a], int_ceil(m[c], m[d])))
processed += 1
continue
# Match ceiling of multiplication with our custom integer functions
m = ceil.match(sympy.ceiling(a * int_floor(c, d)))
if m is not None:
nexpr = nexpr.subs(ceil, m[a] * int_floor(m[c], m[d]))
processed += 1
continue
m = ceil.match(sympy.ceiling(a * int_ceil(c, d)))
if m is not None:
nexpr = nexpr.subs(ceil, m[a] * int_ceil(m[c], m[d]))
processed += 1
continue
for floor in nexpr.find(sympy.floor):
# Simple floor
m = floor.match(sympy.floor(a / b))
if m is not None:
nexpr = nexpr.subs(floor, int_floor(m[a], m[b]))
processed += 1
continue
# Floor of floor: "floor(floor(c/d) / b)"
m = floor.match(sympy.floor(int_floor(c, d) / b))
if m is not None:
nexpr = nexpr.subs(floor, int_floor(int_floor(m[c], m[d]),
m[b]))
processed += 1
continue
# Floor of floor: "floor(a / floor(c/d))"
m = floor.match(sympy.floor(a / int_floor(c, d)))
if m is not None:
nexpr = nexpr.subs(floor, int_floor(m[a],
int_floor(m[c], m[d])))
processed += 1
continue
return nexpr
def test_latex_functions():
assert latex(exp(x)) == "e^{x}"
assert latex(exp(1) + exp(2)) == "e + e^{2}"
f = Function('f')
assert latex(f(x)) == '\\operatorname{f}{\\left (x \\right )}'
beta = Function('beta')
assert latex(beta(x)) == r"\beta{\left (x \right )}"
assert latex(sin(x)) == r"\sin{\left (x \right )}"
assert latex(sin(x), fold_func_brackets=True) == r"\sin {x}"
assert latex(sin(2*x**2), fold_func_brackets=True) == \
r"\sin {2 x^{2}}"
assert latex(sin(x**2), fold_func_brackets=True) == \
r"\sin {x^{2}}"
assert latex(asin(x)**2) == r"\operatorname{asin}^{2}{\left (x \right )}"
assert latex(asin(x)**2, inv_trig_style="full") == \
r"\arcsin^{2}{\left (x \right )}"
assert latex(asin(x)**2, inv_trig_style="power") == \
r"\sin^{-1}{\left (x \right )}^{2}"
assert latex(asin(x**2), inv_trig_style="power",
fold_func_brackets=True) == \
r"\sin^{-1} {x^{2}}"
assert latex(factorial(k)) == r"k!"
assert latex(factorial(-k)) == r"\left(- k\right)!"
assert latex(subfactorial(k)) == r"!k"
assert latex(subfactorial(-k)) == r"!\left(- k\right)"
assert latex(factorial2(k)) == r"k!!"
assert latex(factorial2(-k)) == r"\left(- k\right)!!"
assert latex(binomial(2, k)) == r"{\binom{2}{k}}"
assert latex(FallingFactorial(3,
k)) == r"{\left(3\right)}_{\left(k\right)}"
assert latex(RisingFactorial(3, k)) == r"{\left(3\right)}^{\left(k\right)}"
assert latex(floor(x)) == r"\lfloor{x}\rfloor"
assert latex(ceiling(x)) == r"\lceil{x}\rceil"
assert latex(Min(x, 2, x**3)) == r"\min\left(2, x, x^{3}\right)"
assert latex(Min(x, y)**2) == r"\min\left(x, y\right)^{2}"
assert latex(Max(x, 2, x**3)) == r"\max\left(2, x, x^{3}\right)"
assert latex(Max(x, y)**2) == r"\max\left(x, y\right)^{2}"
assert latex(Abs(x)) == r"\lvert{x}\rvert"
assert latex(re(x)) == r"\Re{x}"
assert latex(re(x + y)) == r"\Re{x} + \Re{y}"
assert latex(im(x)) == r"\Im{x}"
assert latex(conjugate(x)) == r"\overline{x}"
assert latex(gamma(x)) == r"\Gamma\left(x\right)"
assert latex(Order(x)) == r"\mathcal{O}\left(x\right)"
assert latex(lowergamma(x, y)) == r'\gamma\left(x, y\right)'
assert latex(uppergamma(x, y)) == r'\Gamma\left(x, y\right)'
assert latex(cot(x)) == r'\cot{\left (x \right )}'
assert latex(coth(x)) == r'\coth{\left (x \right )}'
assert latex(re(x)) == r'\Re{x}'
assert latex(im(x)) == r'\Im{x}'
assert latex(root(x, y)) == r'x^{\frac{1}{y}}'
assert latex(arg(x)) == r'\arg{\left (x \right )}'
assert latex(zeta(x)) == r'\zeta\left(x\right)'
assert latex(zeta(x)) == r"\zeta\left(x\right)"
assert latex(zeta(x)**2) == r"\zeta^{2}\left(x\right)"
assert latex(zeta(x, y)) == r"\zeta\left(x, y\right)"
assert latex(zeta(x, y)**2) == r"\zeta^{2}\left(x, y\right)"
assert latex(dirichlet_eta(x)) == r"\eta\left(x\right)"
assert latex(dirichlet_eta(x)**2) == r"\eta^{2}\left(x\right)"
assert latex(polylog(x, y)) == r"\operatorname{Li}_{x}\left(y\right)"
assert latex(polylog(x,
y)**2) == r"\operatorname{Li}_{x}^{2}\left(y\right)"
assert latex(lerchphi(x, y, n)) == r"\Phi\left(x, y, n\right)"
assert latex(lerchphi(x, y, n)**2) == r"\Phi^{2}\left(x, y, n\right)"
assert latex(Ei(x)) == r'\operatorname{Ei}{\left (x \right )}'
assert latex(Ei(x)**2) == r'\operatorname{Ei}^{2}{\left (x \right )}'
assert latex(expint(x, y)**2) == r'\operatorname{E}_{x}^{2}\left(y\right)'
assert latex(Shi(x)**2) == r'\operatorname{Shi}^{2}{\left (x \right )}'
assert latex(Si(x)**2) == r'\operatorname{Si}^{2}{\left (x \right )}'
assert latex(Ci(x)**2) == r'\operatorname{Ci}^{2}{\left (x \right )}'
assert latex(Chi(x)**2) == r'\operatorname{Chi}^{2}{\left (x \right )}'
assert latex(jacobi(n, a, b,
x)) == r'P_{n}^{\left(a,b\right)}\left(x\right)'
assert latex(jacobi(
n, a, b,
x)**2) == r'\left(P_{n}^{\left(a,b\right)}\left(x\right)\right)^{2}'
assert latex(gegenbauer(n, a,
x)) == r'C_{n}^{\left(a\right)}\left(x\right)'
assert latex(gegenbauer(
n, a,
x)**2) == r'\left(C_{n}^{\left(a\right)}\left(x\right)\right)^{2}'
assert latex(chebyshevt(n, x)) == r'T_{n}\left(x\right)'
assert latex(chebyshevt(n,
x)**2) == r'\left(T_{n}\left(x\right)\right)^{2}'
assert latex(chebyshevu(n, x)) == r'U_{n}\left(x\right)'
assert latex(chebyshevu(n,
x)**2) == r'\left(U_{n}\left(x\right)\right)^{2}'
assert latex(legendre(n, x)) == r'P_{n}\left(x\right)'
assert latex(legendre(n, x)**2) == r'\left(P_{n}\left(x\right)\right)^{2}'
assert latex(assoc_legendre(n, a,
x)) == r'P_{n}^{\left(a\right)}\left(x\right)'
assert latex(assoc_legendre(
n, a,
x)**2) == r'\left(P_{n}^{\left(a\right)}\left(x\right)\right)^{2}'
assert latex(laguerre(n, x)) == r'L_{n}\left(x\right)'
assert latex(laguerre(n, x)**2) == r'\left(L_{n}\left(x\right)\right)^{2}'
assert latex(assoc_laguerre(n, a,
x)) == r'L_{n}^{\left(a\right)}\left(x\right)'
assert latex(assoc_laguerre(
n, a,
x)**2) == r'\left(L_{n}^{\left(a\right)}\left(x\right)\right)^{2}'
assert latex(hermite(n, x)) == r'H_{n}\left(x\right)'
assert latex(hermite(n, x)**2) == r'\left(H_{n}\left(x\right)\right)^{2}'
# Test latex printing of function names with "_"
assert latex(
polar_lift(0)) == r"\operatorname{polar\_lift}{\left (0 \right )}"
assert latex(polar_lift(0)**
3) == r"\operatorname{polar\_lift}^{3}{\left (0 \right )}"
def floor_divide(x1, x2):
"""floor_divide(x1, x2)
Return the largest integer smaller or equal to the division of the inputs.
"""
return floor(divide(x1, x2))
def apply_real(self, x, evaluation):
'Floor[x_]'
x = x.to_sympy()
return from_sympy(sympy.floor(x))
def test_issue_14313_comment():
assert limit(floor(n / 2), n, oo) is oo
def test_floor():
x = Symbol('x')
assert floor(x).series(x) == 0
assert floor(-x).series(x) == -1
assert floor(sin(x)).series(x) == 0
assert floor(sin(-x)).series(x) == -1
assert floor(x**3).series(x) == 0
assert floor(-x**3).series(x) == -1
assert floor(cos(x)).series(x) == 0
assert floor(cos(-x)).series(x) == 0
assert floor(5 + sin(x)).series(x) == 5
assert floor(5 + sin(-x)).series(x) == 4
assert floor(x).series(x, 2) == 2
assert floor(-x).series(x, 2) == -3
x = Symbol('x', negative=True)
assert floor(x + 1.5).series(x) == 1
def test_issue_13098():
assert floor(log(S('9.' + '9' * 20), 10)) == 0
assert ceiling(log(S('9.' + '9' * 20), 10)) == 1
assert floor(log(20 - S('9.' + '9' * 20), 10)) == 1
assert ceiling(log(20 - S('9.' + '9' * 20), 10)) == 2