def test_Integer():
assert mcode(Integer(67)) == "67"
assert mcode(Integer(-1)) == "-1"
def args(self):
return (self.expr, Integer(self.index))
def test_negative_real():
def feq(a, b):
return abs(a - b) < 1E-10
assert feq(S.One / Float(-0.5), -Integer(2))
def test_Integer():
assert rust_code(Integer(42)) == "42"
assert rust_code(Integer(-56)) == "-56"
from sympy.core import Symbol, Integer
x = Symbol('x')
i3 = Integer(3)
def timeit_x_is_integer():
x.is_integer
def timeit_Integer_is_irrational():
i3.is_irrational
def nP(n, k=None, replacement=False):
"""Return the number of permutations of ``n`` items taken ``k`` at a time.
Possible values for ``n``::
integer - set of length ``n``
sequence - converted to a multiset internally
multiset - {element: multiplicity}
If ``k`` is None then the total of all permutations of length 0
through the number of items represented by ``n`` will be returned.
If ``replacement`` is True then a given item can appear more than once
in the ``k`` items. (For example, for 'ab' permutations of 2 would
include 'aa', 'ab', 'ba' and 'bb'.) The multiplicity of elements in
``n`` is ignored when ``replacement`` is True but the total number
of elements is considered since no element can appear more times than
the number of elements in ``n``.
Examples
========
>>> from sympy.functions.combinatorial.numbers import nP
>>> from sympy.utilities.iterables import multiset_permutations, multiset
>>> nP(3, 2)
6
>>> nP('abc', 2) == nP(multiset('abc'), 2) == 6
True
>>> nP('aab', 2)
3
>>> nP([1, 2, 2], 2)
3
>>> [nP(3, i) for i in range(4)]
[1, 3, 6, 6]
>>> nP(3) == sum(_)
True
When ``replacement`` is True, each item can have multiplicity
equal to the length represented by ``n``:
>>> nP('aabc', replacement=True)
121
>>> [len(list(multiset_permutations('aaaabbbbcccc', i))) for i in range(5)]
[1, 3, 9, 27, 81]
>>> sum(_)
121
References
==========
.. [1] http://en.wikipedia.org/wiki/Permutation
See Also
========
sympy.utilities.iterables.multiset_permutations
"""
try:
n = as_int(n)
except ValueError:
return Integer(_nP(_multiset_histogram(n), k, replacement))
return Integer(_nP(n, k, replacement))
def test_jscode_Integer():
assert jscode(Integer(67)) == "67"
assert jscode(Integer(-1)) == "-1"
def kronecker_mv(f, **flags):
"""Kronecker method for Z[X] polynomials.
NOTE: This function is very slow even on small input.
Use debug=True flag to see its progress, if any.
"""
symbols = f.symbols
def mv_int_div(f, g):
q = Poly((), *symbols)
r = Poly((), *symbols)
while not f.is_zero:
lc_f, lc_g = f.LC, g.LC
dv = lc_f % lc_g
cf = lc_f / lc_g
monom = monomial_div(f.LM, g.LM)
if dv == 0 and monom is not None:
q = q.add_term(cf, monom)
f -= g.mul_term(cf, monom)
else:
r = r.add_term(*f.LT)
f = f.kill_lead_term()
return q, r
def combinations(lisp, m):
def recursion(fa, lisp, m):
if m == 0:
yield fa
else:
for i, fa2 in enumerate(lisp[0:len(lisp) + 1 - m]):
for el in recursion(zzx_mul(fa2, fa), list(lisp[i + 1:]),
m - 1):
yield el
for i, fa in enumerate(lisp[0:len(lisp) + 1 - m]):
for el in recursion(fa, list(lisp[i + 1:]), m - 1):
yield el
debug = flags.get('debug', False)
cont, f = f.as_primitive()
N = len(symbols)
max_exp = {}
for v in symbols:
max_exp[v] = 0
for coeff, monom in f.iter_terms():
for v, exp in zip(symbols, monom):
if exp > max_exp[v]:
max_exp[v] = exp
symbols = sorted(symbols, reverse=True, key=lambda v: max_exp[v])
f = Poly(f, *symbols)
d = max_exp[symbols[0]] + 1
terms, exps = {}, []
for i in xrange(0, len(symbols)):
exps.append(d**i)
for coeff, monom in f.iter_terms():
exp = 0
for i, expi in enumerate(monom):
exp += expi * exps[i]
terms[exp] = int(coeff)
g, factors = zzx_from_dict(terms), []
try:
for ff, k in zzx_factor(g)[1]:
for i in xrange(0, k):
factors.append(ff)
except OverflowError:
raise PolynomialError(
"input too large for multivariate Kronecker method")
const, result, tested = 1, [], []
if debug: print "KRONECKER-MV: Z[x] #factors = %i ..." % (len(factors))
for k in range(1, len(factors) // 2 + 1):
for h in combinations(factors, k):
if h in tested:
continue
n = zzx_degree(h)
terms = {}
for coeff in h:
if not coeff:
n = n - 1
continue
else:
coeff = Integer(coeff)
y_deg, n = n, n - 1
monom = [0] * N
for i in xrange(N):
v_deg = y_deg % d
y_deg = (y_deg - v_deg) // d
monom[i] = v_deg
monom = tuple(monom)
if terms.has_key(monom):
terms[monom] += coeff
else:
terms[monom] = coeff
cand = Poly(terms, *symbols)
if cand.is_one:
continue
if cand.LC.is_negative:
cand = -cand
q, r = mv_int_div(f, cand)
if r.is_zero:
if debug: print "KRONECKER-MV: Z[X] factor found %s" % cand
result.append(cand)
f = q
else:
tested.append(h)
if f.is_constant:
const, f = f.LC, Poly(1, *symbols)
break
if f.is_one:
break
if not f.is_one:
if debug: print "KRONECKER-MV: Z[X] factor found %s" % f
result.append(f)
factors = {}
for ff in result:
if factors.has_key(ff):
factors[ff] += 1
else:
factors[ff] = 1
return cont * const, sorted(factors.items())
def test_glsl_code_Integer():
assert glsl_code(Integer(67)) == "67"
assert glsl_code(Integer(-1)) == "-1"
def test_local_dict():
local_dict = {'my_function': lambda x: x + 2}
inputs = {'my_function(2)': Integer(4)}
for text, result in inputs.items():
assert parse_expr(text, local_dict=local_dict) == result
def test_sympy_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),
'x!':
factorial(x),
'x!!':
factorial2(x),
'(x + 1)! - 1':
factorial(x + 1) - 1,
'3.[3]':
Rational(10, 3),
'.0[3]':
Rational(1, 30),
'3.2[3]':
Rational(97, 30),
'1.3[12]':
Rational(433, 330),
'1 + 3.[3]':
Rational(13, 3),
'1 + .0[3]':
Rational(31, 30),
'1 + 3.2[3]':
Rational(127, 30),
'.[0011]':
Rational(1, 909),
'0.1[00102] + 1':
Rational(366697, 333330),
'1.[0191]':
Rational(10190, 9999),
'10!':
3628800,
'-(2)':
-Integer(2),
'[-1, -2, 3]': [Integer(-1), Integer(-2),
Integer(3)],
'Symbol("x").free_symbols':
x.free_symbols,
"S('S(3).n(n=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='-'),
'Q.even(x)':
Q.even(x),
}
for text, result in inputs.items():
assert parse_expr(text) == result
raises(TypeError, lambda: parse_expr('x', standard_transformations))
raises(TypeError, lambda: parse_expr('x', transformations=lambda x, y: 1))
raises(TypeError,
lambda: parse_expr('x', transformations=(lambda x, y: 1,
)))
raises(TypeError, lambda: parse_expr('x', transformations=((), )))
raises(TypeError, lambda: parse_expr('x', {}, [], []))
raises(TypeError, lambda: parse_expr('x', [], [], {}))
raises(TypeError, lambda: parse_expr('x', [], [], {}))
def __new__(cls, sample):
s = tuple.__new__(cls, sample)
s.mean = mean = sum(s) / Integer(len(s))
s.variance = sum([(x-mean)**2 for x in s]) / Integer(len(s))
s.stddev = sqrt(s.variance)
return s