def solve_eqn(self):
q, betasq, ml, md, m0 = sympy.symbols('q,betasq,ml,md,m0')
nbetasq = self.model_betasq()
eqn1, eqn2, eqn3, eqn4, eqn5 = self.get_eqns()
sols = sympy.solve([eqn1.subs(betasq, nbetasq),
eqn2.subs(betasq, nbetasq),
eqn3.subs(betasq, nbetasq),
eqn4.subs(betasq, nbetasq)],
[q, ml, md, m0])
isAllReal = lambda item: im(item[0])==0 and im(item[1])==0 and im(item[2])==0 and im(item[3])==0
sols = filter(isAllReal, sols)
isValid = lambda item: item[0]>0 and item[1]>=0 and item[2]>=0 and item[3]>0
sols = filter(isValid, sols)
return sols
def roots_binomial(f):
"""Returns a list of roots of a binomial polynomial."""
n = f.degree()
a, b = f.nth(n), f.nth(0)
alpha = (-cancel(b / a))**Rational(1, n)
if alpha.is_number:
alpha = alpha.expand(complex=True)
roots, I = [], S.ImaginaryUnit
for k in xrange(n):
zeta = exp(2 * k * S.Pi * I / n).expand(complex=True)
roots.append((alpha * zeta).expand(power_base=False))
if all([r.is_number for r in roots]):
reals, complexes = [], []
for root in roots:
if root.is_real:
reals.append(root)
else:
complexes.append(root)
roots = sorted(reals) + sorted(complexes,
key=lambda r: (re(r), -im(r)))
return roots
def roots_binomial(f):
"""Returns a list of roots of a binomial polynomial."""
n = f.degree()
a, b = f.nth(n), f.nth(0)
alpha = (-cancel(b/a))**Rational(1, n)
if alpha.is_number:
alpha = alpha.expand(complex=True)
roots, I = [], S.ImaginaryUnit
for k in xrange(n):
zeta = exp(2*k*S.Pi*I/n).expand(complex=True)
roots.append((alpha*zeta).expand(power_base=False))
if all([ r.is_number for r in roots ]):
reals, complexes = [], []
for root in roots:
if root.is_real:
reals.append(root)
else:
complexes.append(root)
roots = sorted(reals) + sorted(complexes, key=lambda r: (re(r), -im(r)))
return roots
def solve_eqn(self):
q, betasq, ml, md, m0 = sympy.symbols('q,betasq,ml,md,m0')
nbetasq = self.model_betasq()
eqn1, eqn2, eqn3, eqn4, eqn5 = self.get_eqns()
sols = sympy.solve([
eqn1.subs(betasq, nbetasq),
eqn2.subs(betasq, nbetasq),
eqn3.subs(betasq, nbetasq),
eqn4.subs(betasq, nbetasq)
], [q, ml, md, m0])
isAllReal = lambda item: im(item[0]) == 0 and im(item[1]) == 0 and im(
item[2]) == 0 and im(item[3]) == 0
sols = filter(isAllReal, sols)
isValid = lambda item: item[0] > 0 and item[1] >= 0 and item[
2] >= 0 and item[3] > 0
sols = filter(isValid, sols)
return sols
def reduce_poly_inequalities(exprs, gen, assume=True, relational=True):
"""Reduce a system of polynomial inequalities with rational coefficients. """
exact = True
polys = []
for _exprs in exprs:
_polys = []
for expr in _exprs:
if isinstance(expr, tuple):
expr, rel = expr
else:
if expr.is_Relational:
expr, rel = expr.lhs - expr.rhs, expr.rel_op
else:
expr, rel = expr, '=='
poly = Poly(expr, gen)
if not poly.get_domain().is_Exact:
poly, exact = poly.to_exact(), False
domain = poly.get_domain()
if not (domain.is_ZZ or domain.is_QQ):
raise NotImplementedError(
"inequality solving is not supported over %s" % domain)
_polys.append((poly, rel))
polys.append(_polys)
solution = solve_poly_inequalities(polys)
if isinstance(solution, Union):
intervals = list(solution.args)
elif isinstance(solution, Interval):
intervals = [solution]
else:
intervals = []
if not exact:
intervals = map(interval_evalf, intervals)
if not relational:
return intervals
real = ask(gen, 'real', assume)
def relationalize(gen):
return Or(*[i.as_relational(gen) for i in intervals])
if not real:
result = And(relationalize(re(gen)), Eq(im(gen), 0))
else:
result = relationalize(gen)
return result
def test_even():
x, y, z, t = symbols('x,y,z,t')
assert ask(x, Q.even) == None
assert ask(x, Q.even, Assume(x, Q.integer)) == None
assert ask(x, Q.even, Assume(x, Q.integer, False)) == False
assert ask(x, Q.even, Assume(x, Q.rational)) == None
assert ask(x, Q.even, Assume(x, Q.positive)) == None
assert ask(2 * x, Q.even) == None
assert ask(2 * x, Q.even, Assume(x, Q.integer)) == True
assert ask(2 * x, Q.even, Assume(x, Q.even)) == True
assert ask(2 * x, Q.even, Assume(x, Q.irrational)) == False
assert ask(2 * x, Q.even, Assume(x, Q.odd)) == True
assert ask(2 * x, Q.even, Assume(x, Q.integer, False)) == None
assert ask(3 * x, Q.even, Assume(x, Q.integer)) == None
assert ask(3 * x, Q.even, Assume(x, Q.even)) == True
assert ask(3 * x, Q.even, Assume(x, Q.odd)) == False
assert ask(x + 1, Q.even, Assume(x, Q.odd)) == True
assert ask(x + 1, Q.even, Assume(x, Q.even)) == False
assert ask(x + 2, Q.even, Assume(x, Q.odd)) == False
assert ask(x + 2, Q.even, Assume(x, Q.even)) == True
assert ask(7 - x, Q.even, Assume(x, Q.odd)) == True
assert ask(7 + x, Q.even, Assume(x, Q.odd)) == True
assert ask(x + y, Q.even, Assume(x, Q.odd) & Assume(y, Q.odd)) == True
assert ask(x + y, Q.even, Assume(x, Q.odd) & Assume(y, Q.even)) == False
assert ask(x + y, Q.even, Assume(x, Q.even) & Assume(y, Q.even)) == True
assert ask(2 * x + 1, Q.even, Assume(x, Q.integer)) == False
assert ask(2 * x * y, Q.even,
Assume(x, Q.rational) & Assume(x, Q.rational)) == None
assert ask(2 * x * y, Q.even,
Assume(x, Q.irrational) & Assume(x, Q.irrational)) == None
assert ask(x+y+z, Q.even, Assume(x, Q.odd) & Assume(y, Q.odd) & \
Assume(z, Q.even)) == True
assert ask(x+y+z+t, Q.even, Assume(x, Q.odd) & Assume(y, Q.odd) & \
Assume(z, Q.even) & Assume(t, Q.integer)) == None
assert ask(Abs(x), Q.even, Assume(x, Q.even)) == True
assert ask(Abs(x), Q.even, Assume(x, Q.even, False)) == None
assert ask(re(x), Q.even, Assume(x, Q.even)) == True
assert ask(re(x), Q.even, Assume(x, Q.even, False)) == None
assert ask(im(x), Q.even, Assume(x, Q.even)) == True
assert ask(im(x), Q.even, Assume(x, Q.real)) == True
def reduce_poly_inequalities(exprs, gen, assume=True, relational=True):
"""Reduce a system of polynomial inequalities with rational coefficients. """
exact = True
polys = []
for _exprs in exprs:
_polys = []
for expr in _exprs:
if isinstance(expr, tuple):
expr, rel = expr
else:
if expr.is_Relational:
expr, rel = expr.lhs - expr.rhs, expr.rel_op
else:
expr, rel = expr, '=='
poly = Poly(expr, gen)
if not poly.get_domain().is_Exact:
poly, exact = poly.to_exact(), False
domain = poly.get_domain()
if not (domain.is_ZZ or domain.is_QQ):
raise NotImplementedError("inequality solving is not supported over %s" % domain)
_polys.append((poly, rel))
polys.append(_polys)
solution = solve_poly_inequalities(polys)
if isinstance(solution, Union):
intervals = list(solution.args)
elif isinstance(solution, Interval):
intervals = [solution]
else:
intervals = []
if not exact:
intervals = map(interval_evalf, intervals)
if not relational:
return intervals
real = ask(gen, 'real', assume)
def relationalize(gen):
return Or(*[ i.as_relational(gen) for i in intervals ])
if not real:
result = And(relationalize(re(gen)), Eq(im(gen), 0))
else:
result = relationalize(gen)
return result
def test_even():
x, y, z, t = symbols("x,y,z,t")
assert ask(x, Q.even) == None
assert ask(x, Q.even, Assume(x, Q.integer)) == None
assert ask(x, Q.even, Assume(x, Q.integer, False)) == False
assert ask(x, Q.even, Assume(x, Q.rational)) == None
assert ask(x, Q.even, Assume(x, Q.positive)) == None
assert ask(2 * x, Q.even) == None
assert ask(2 * x, Q.even, Assume(x, Q.integer)) == True
assert ask(2 * x, Q.even, Assume(x, Q.even)) == True
assert ask(2 * x, Q.even, Assume(x, Q.irrational)) == False
assert ask(2 * x, Q.even, Assume(x, Q.odd)) == True
assert ask(2 * x, Q.even, Assume(x, Q.integer, False)) == None
assert ask(3 * x, Q.even, Assume(x, Q.integer)) == None
assert ask(3 * x, Q.even, Assume(x, Q.even)) == True
assert ask(3 * x, Q.even, Assume(x, Q.odd)) == False
assert ask(x + 1, Q.even, Assume(x, Q.odd)) == True
assert ask(x + 1, Q.even, Assume(x, Q.even)) == False
assert ask(x + 2, Q.even, Assume(x, Q.odd)) == False
assert ask(x + 2, Q.even, Assume(x, Q.even)) == True
assert ask(7 - x, Q.even, Assume(x, Q.odd)) == True
assert ask(7 + x, Q.even, Assume(x, Q.odd)) == True
assert ask(x + y, Q.even, Assume(x, Q.odd) & Assume(y, Q.odd)) == True
assert ask(x + y, Q.even, Assume(x, Q.odd) & Assume(y, Q.even)) == False
assert ask(x + y, Q.even, Assume(x, Q.even) & Assume(y, Q.even)) == True
assert ask(2 * x + 1, Q.even, Assume(x, Q.integer)) == False
assert ask(2 * x * y, Q.even, Assume(x, Q.rational) & Assume(x, Q.rational)) == None
assert ask(2 * x * y, Q.even, Assume(x, Q.irrational) & Assume(x, Q.irrational)) == None
assert ask(x + y + z, Q.even, Assume(x, Q.odd) & Assume(y, Q.odd) & Assume(z, Q.even)) == True
assert (
ask(x + y + z + t, Q.even, Assume(x, Q.odd) & Assume(y, Q.odd) & Assume(z, Q.even) & Assume(t, Q.integer))
== None
)
assert ask(Abs(x), Q.even, Assume(x, Q.even)) == True
assert ask(Abs(x), Q.even, Assume(x, Q.even, False)) == None
assert ask(re(x), Q.even, Assume(x, Q.even)) == True
assert ask(re(x), Q.even, Assume(x, Q.even, False)) == None
assert ask(im(x), Q.even, Assume(x, Q.even)) == True
assert ask(im(x), Q.even, Assume(x, Q.real)) == True
def test_Function():
assert mcode(sin(x)**cos(x)) == "sin(x).^cos(x)"
assert mcode(abs(x)) == "abs(x)"
assert mcode(ceiling(x)) == "ceil(x)"
assert mcode(arg(x)) == "angle(x)"
assert mcode(im(x)) == "imag(x)"
assert mcode(re(x)) == "real(x)"
assert mcode(Max(x, y) + Min(x, y)) == "max(x, y) + min(x, y)"
assert mcode(Max(x, y, z)) == "max(x, max(y, z))"
assert mcode(Min(x, y, z)) == "min(x, min(y, z))"
def test_Function():
assert mcode(sin(x) ** cos(x)) == "sin(x).^cos(x)"
assert mcode(abs(x)) == "abs(x)"
assert mcode(ceiling(x)) == "ceil(x)"
assert mcode(arg(x)) == "angle(x)"
assert mcode(im(x)) == "imag(x)"
assert mcode(re(x)) == "real(x)"
assert mcode(Max(x, y) + Min(x, y)) == "max(x, y) + min(x, y)"
assert mcode(Max(x, y, z)) == "max(x, max(y, z))"
assert mcode(Min(x, y, z)) == "min(x, min(y, z))"
def test_even():
x, y, z, t = symbols('x,y,z,t')
assert ask(Q.even(x)) == None
assert ask(Q.even(x), Q.integer(x)) == None
assert ask(Q.even(x), ~Q.integer(x)) == False
assert ask(Q.even(x), Q.rational(x)) == None
assert ask(Q.even(x), Q.positive(x)) == None
assert ask(Q.even(2 * x)) == None
assert ask(Q.even(2 * x), Q.integer(x)) == True
assert ask(Q.even(2 * x), Q.even(x)) == True
assert ask(Q.even(2 * x), Q.irrational(x)) == False
assert ask(Q.even(2 * x), Q.odd(x)) == True
assert ask(Q.even(2 * x), ~Q.integer(x)) == None
assert ask(Q.even(3 * x), Q.integer(x)) == None
assert ask(Q.even(3 * x), Q.even(x)) == True
assert ask(Q.even(3 * x), Q.odd(x)) == False
assert ask(Q.even(x + 1), Q.odd(x)) == True
assert ask(Q.even(x + 1), Q.even(x)) == False
assert ask(Q.even(x + 2), Q.odd(x)) == False
assert ask(Q.even(x + 2), Q.even(x)) == True
assert ask(Q.even(7 - x), Q.odd(x)) == True
assert ask(Q.even(7 + x), Q.odd(x)) == True
assert ask(Q.even(x + y), Q.odd(x) & Q.odd(y)) == True
assert ask(Q.even(x + y), Q.odd(x) & Q.even(y)) == False
assert ask(Q.even(x + y), Q.even(x) & Q.even(y)) == True
assert ask(Q.even(2 * x + 1), Q.integer(x)) == False
assert ask(Q.even(2 * x * y), Q.rational(x) & Q.rational(x)) == None
assert ask(Q.even(2 * x * y), Q.irrational(x) & Q.irrational(x)) == None
assert ask(Q.even(x + y + z), Q.odd(x) & Q.odd(y) & Q.even(z)) == True
assert ask(Q.even(x + y + z + t),
Q.odd(x) & Q.odd(y) & Q.even(z) & Q.integer(t)) == None
assert ask(Q.even(Abs(x)), Q.even(x)) == True
assert ask(Q.even(Abs(x)), ~Q.even(x)) == None
assert ask(Q.even(re(x)), Q.even(x)) == True
assert ask(Q.even(re(x)), ~Q.even(x)) == None
assert ask(Q.even(im(x)), Q.even(x)) == True
assert ask(Q.even(im(x)), Q.real(x)) == True
def test_even():
x, y, z, t = symbols('x,y,z,t')
assert ask(Q.even(x)) == None
assert ask(Q.even(x), Q.integer(x)) == None
assert ask(Q.even(x), ~Q.integer(x)) == False
assert ask(Q.even(x), Q.rational(x)) == None
assert ask(Q.even(x), Q.positive(x)) == None
assert ask(Q.even(2*x)) == None
assert ask(Q.even(2*x), Q.integer(x)) == True
assert ask(Q.even(2*x), Q.even(x)) == True
assert ask(Q.even(2*x), Q.irrational(x)) == False
assert ask(Q.even(2*x), Q.odd(x)) == True
assert ask(Q.even(2*x), ~Q.integer(x)) == None
assert ask(Q.even(3*x), Q.integer(x)) == None
assert ask(Q.even(3*x), Q.even(x)) == True
assert ask(Q.even(3*x), Q.odd(x)) == False
assert ask(Q.even(x+1), Q.odd(x)) == True
assert ask(Q.even(x+1), Q.even(x)) == False
assert ask(Q.even(x+2), Q.odd(x)) == False
assert ask(Q.even(x+2), Q.even(x)) == True
assert ask(Q.even(7-x), Q.odd(x)) == True
assert ask(Q.even(7+x), Q.odd(x)) == True
assert ask(Q.even(x+y), Q.odd(x) & Q.odd(y)) == True
assert ask(Q.even(x+y), Q.odd(x) & Q.even(y)) == False
assert ask(Q.even(x+y), Q.even(x) & Q.even(y)) == True
assert ask(Q.even(2*x + 1), Q.integer(x)) == False
assert ask(Q.even(2*x*y), Q.rational(x) & Q.rational(x)) == None
assert ask(Q.even(2*x*y), Q.irrational(x) & Q.irrational(x)) == None
assert ask(Q.even(x+y+z), Q.odd(x) & Q.odd(y) & Q.even(z)) == True
assert ask(Q.even(x+y+z+t),
Q.odd(x) & Q.odd(y) & Q.even(z) & Q.integer(t)) == None
assert ask(Q.even(Abs(x)), Q.even(x)) == True
assert ask(Q.even(Abs(x)), ~Q.even(x)) == None
assert ask(Q.even(re(x)), Q.even(x)) == True
assert ask(Q.even(re(x)), ~Q.even(x)) == None
assert ask(Q.even(im(x)), Q.even(x)) == True
assert ask(Q.even(im(x)), Q.real(x)) == True
def change_matrix_type(matrix, num_to_sym=1): """ Change a matrix or array from numpy to sympy and a sympy matrix to numpy matrix. """ if num_to_sym: n = len(matrix) new_matrix = sp.Matrix([[matrix[i,j] for j in range(n)] for i in range(n)]) else: n = int(sqrt(len(matrix))) new_matrix = np.matrix([[complex(fun.re(matrix[i,j]), fun.im(matrix[i,j])) for j in range(n)] for i in range(n)]) return new_matrix
def findPrimitiveRoot(n):
if (n == 1):
return solve(x - 1)[0]
else:
unorderedRoots = solve(x**n - 1)
if unorderedRoots[0] != 1:
currentMax = unorderedRoots[0]
else:
currentMax = unorderedRoots[1]
for item in unorderedRoots:
if re(item) >= re(currentMax) and im(item) > 0:
currentMax = item
return currentMax
def eqFinder(r, K, q, eL, eH, p, w, gamma):
n = Symbol('n')
A = solve(
p * q * n - p * q * r * gamma * n**2 + p * q * r * gamma * n**3 / K -
w, n)
B = np.array(A)
C = B.astype('complex128')
nStar = np.zeros(len(C))
for i in range(len(C)):
if np.abs(im(C[i])) < .001:
nStar[i] = re(C[i])
else:
nStar[i] = np.nan
xStar = eH / (eH - eL) - (r) / (q * (eH - eL)) * (1 - 1 / K * nStar)
return (xStar, nStar)
def reduce_poly_inequalities(exprs, gen, assume=True, relational=True):
"""Reduce a system of polynomial inequalities with rational coefficients. """
exact = True
polys = []
for _exprs in exprs:
_polys = []
for expr in _exprs:
if isinstance(expr, tuple):
expr, rel = expr
else:
if expr.is_Relational:
expr, rel = expr.lhs - expr.rhs, expr.rel_op
else:
expr, rel = expr, '=='
poly = Poly(expr, gen)
if not poly.get_domain().is_Exact:
poly, exact = poly.to_exact(), False
domain = poly.get_domain()
if not (domain.is_ZZ or domain.is_QQ):
raise NotImplementedError(
"inequality solving is not supported over %s" % domain)
_polys.append((poly, rel))
polys.append(_polys)
solution = solve_poly_inequalities(polys)
if not exact:
solution = solution.evalf()
if not relational:
return solution
real = ask(Q.real(gen), assumptions=assume)
if not real:
result = And(solution.as_relational(re(gen)), Eq(im(gen), 0))
else:
result = solution.as_relational(gen)
return result
def reduce_poly_inequalities(exprs, gen, assume=True, relational=True):
"""Reduce a system of polynomial inequalities with rational coefficients. """
exact = True
polys = []
for _exprs in exprs:
_polys = []
for expr in _exprs:
if isinstance(expr, tuple):
expr, rel = expr
else:
if expr.is_Relational:
expr, rel = expr.lhs - expr.rhs, expr.rel_op
else:
expr, rel = expr, "=="
poly = Poly(expr, gen)
if not poly.get_domain().is_Exact:
poly, exact = poly.to_exact(), False
domain = poly.get_domain()
if not (domain.is_ZZ or domain.is_QQ):
raise NotImplementedError("inequality solving is not supported over %s" % domain)
_polys.append((poly, rel))
polys.append(_polys)
solution = solve_poly_inequalities(polys)
if not exact:
solution = solution.evalf()
if not relational:
return solution
real = ask(Q.real(gen), assumptions=assume)
if not real:
result = And(solution.as_relational(re(gen)), Eq(im(gen), 0))
else:
result = solution.as_relational(gen)
return result
def test_real():
x, y = symbols('x y')
assert ask(x, Q.real) == None
assert ask(x, Q.real, Assume(x, Q.real)) == True
assert ask(x, Q.real, Assume(x, Q.nonzero)) == True
assert ask(x, Q.real, Assume(x, Q.positive)) == True
assert ask(x, Q.real, Assume(x, Q.negative)) == True
assert ask(x, Q.real, Assume(x, Q.integer)) == True
assert ask(x, Q.real, Assume(x, Q.even)) == True
assert ask(x, Q.real, Assume(x, Q.prime)) == True
assert ask(x/sqrt(2), Q.real, Assume(x, Q.real)) == True
assert ask(x/sqrt(-2), Q.real, Assume(x, Q.real)) == False
I = S.ImaginaryUnit
assert ask(x+1, Q.real, Assume(x, Q.real)) == True
assert ask(x+I, Q.real, Assume(x, Q.real)) == False
assert ask(x+I, Q.real, Assume(x, Q.complex)) == None
assert ask(2*x, Q.real, Assume(x, Q.real)) == True
assert ask(I*x, Q.real, Assume(x, Q.real)) == False
assert ask(I*x, Q.real, Assume(x, Q.imaginary)) == True
assert ask(I*x, Q.real, Assume(x, Q.complex)) == None
assert ask(x**2, Q.real, Assume(x, Q.real)) == True
assert ask(sqrt(x), Q.real, Assume(x, Q.negative)) == False
assert ask(x**y, Q.real, Assume(x, Q.real) & Assume(y, Q.integer)) == True
assert ask(x**y, Q.real, Assume(x, Q.real) & Assume(y, Q.real)) == None
assert ask(x**y, Q.real, Assume(x, Q.positive) & \
Assume(y, Q.real)) == True
# trigonometric functions
assert ask(sin(x), Q.real) == None
assert ask(cos(x), Q.real) == None
assert ask(sin(x), Q.real, Assume(x, Q.real)) == True
assert ask(cos(x), Q.real, Assume(x, Q.real)) == True
# exponential function
assert ask(exp(x), Q.real) == None
assert ask(exp(x), Q.real, Assume(x, Q.real)) == True
assert ask(x + exp(x), Q.real, Assume(x, Q.real)) == True
# Q.complexes
assert ask(re(x), Q.real) == True
assert ask(im(x), Q.real) == True
def test_real():
x, y = symbols('x,y')
assert ask(Q.real(x)) == None
assert ask(Q.real(x), Q.real(x)) == True
assert ask(Q.real(x), Q.nonzero(x)) == True
assert ask(Q.real(x), Q.positive(x)) == True
assert ask(Q.real(x), Q.negative(x)) == True
assert ask(Q.real(x), Q.integer(x)) == True
assert ask(Q.real(x), Q.even(x)) == True
assert ask(Q.real(x), Q.prime(x)) == True
assert ask(Q.real(x/sqrt(2)), Q.real(x)) == True
assert ask(Q.real(x/sqrt(-2)), Q.real(x)) == False
I = S.ImaginaryUnit
assert ask(Q.real(x+1), Q.real(x)) == True
assert ask(Q.real(x+I), Q.real(x)) == False
assert ask(Q.real(x+I), Q.complex(x)) == None
assert ask(Q.real(2*x), Q.real(x)) == True
assert ask(Q.real(I*x), Q.real(x)) == False
assert ask(Q.real(I*x), Q.imaginary(x)) == True
assert ask(Q.real(I*x), Q.complex(x)) == None
assert ask(Q.real(x**2), Q.real(x)) == True
assert ask(Q.real(sqrt(x)), Q.negative(x)) == False
assert ask(Q.real(x**y), Q.real(x) & Q.integer(y)) == True
assert ask(Q.real(x**y), Q.real(x) & Q.real(y)) == None
assert ask(Q.real(x**y), Q.positive(x) & Q.real(y)) == True
# trigonometric functions
assert ask(Q.real(sin(x))) == None
assert ask(Q.real(cos(x))) == None
assert ask(Q.real(sin(x)), Q.real(x)) == True
assert ask(Q.real(cos(x)), Q.real(x)) == True
# exponential function
assert ask(Q.real(exp(x))) == None
assert ask(Q.real(exp(x)), Q.real(x)) == True
assert ask(Q.real(x + exp(x)), Q.real(x)) == True
# Q.complexes
assert ask(Q.real(re(x))) == True
assert ask(Q.real(im(x))) == True
def test_real():
x, y = symbols('x,y')
assert ask(Q.real(x)) == None
assert ask(Q.real(x), Q.real(x)) == True
assert ask(Q.real(x), Q.nonzero(x)) == True
assert ask(Q.real(x), Q.positive(x)) == True
assert ask(Q.real(x), Q.negative(x)) == True
assert ask(Q.real(x), Q.integer(x)) == True
assert ask(Q.real(x), Q.even(x)) == True
assert ask(Q.real(x), Q.prime(x)) == True
assert ask(Q.real(x / sqrt(2)), Q.real(x)) == True
assert ask(Q.real(x / sqrt(-2)), Q.real(x)) == False
I = S.ImaginaryUnit
assert ask(Q.real(x + 1), Q.real(x)) == True
assert ask(Q.real(x + I), Q.real(x)) == False
assert ask(Q.real(x + I), Q.complex(x)) == None
assert ask(Q.real(2 * x), Q.real(x)) == True
assert ask(Q.real(I * x), Q.real(x)) == False
assert ask(Q.real(I * x), Q.imaginary(x)) == True
assert ask(Q.real(I * x), Q.complex(x)) == None
assert ask(Q.real(x**2), Q.real(x)) == True
assert ask(Q.real(sqrt(x)), Q.negative(x)) == False
assert ask(Q.real(x**y), Q.real(x) & Q.integer(y)) == True
assert ask(Q.real(x**y), Q.real(x) & Q.real(y)) == None
assert ask(Q.real(x**y), Q.positive(x) & Q.real(y)) == True
# trigonometric functions
assert ask(Q.real(sin(x))) == None
assert ask(Q.real(cos(x))) == None
assert ask(Q.real(sin(x)), Q.real(x)) == True
assert ask(Q.real(cos(x)), Q.real(x)) == True
# exponential function
assert ask(Q.real(exp(x))) == None
assert ask(Q.real(exp(x)), Q.real(x)) == True
assert ask(Q.real(x + exp(x)), Q.real(x)) == True
# Q.complexes
assert ask(Q.real(re(x))) == True
assert ask(Q.real(im(x))) == True
def test_Function_change_name():
assert mcode(abs(x)) == "abs(x)"
assert mcode(ceiling(x)) == "ceil(x)"
assert mcode(arg(x)) == "angle(x)"
assert mcode(im(x)) == "imag(x)"
assert mcode(re(x)) == "real(x)"
assert mcode(conjugate(x)) == "conj(x)"
assert mcode(chebyshevt(y, x)) == "chebyshevT(y, x)"
assert mcode(chebyshevu(y, x)) == "chebyshevU(y, x)"
assert mcode(laguerre(x, y)) == "laguerreL(x, y)"
assert mcode(Chi(x)) == "coshint(x)"
assert mcode(Shi(x)) == "sinhint(x)"
assert mcode(Ci(x)) == "cosint(x)"
assert mcode(Si(x)) == "sinint(x)"
assert mcode(li(x)) == "logint(x)"
assert mcode(loggamma(x)) == "gammaln(x)"
assert mcode(polygamma(x, y)) == "psi(x, y)"
assert mcode(RisingFactorial(x, y)) == "pochhammer(x, y)"
assert mcode(DiracDelta(x)) == "dirac(x)"
assert mcode(DiracDelta(x, 3)) == "dirac(3, x)"
assert mcode(Heaviside(x)) == "heaviside(x)"
assert mcode(Heaviside(x, y)) == "heaviside(x, y)"
def test_Function_change_name():
assert mcode(abs(x)) == "abs(x)"
assert mcode(ceiling(x)) == "ceil(x)"
assert mcode(arg(x)) == "angle(x)"
assert mcode(im(x)) == "imag(x)"
assert mcode(re(x)) == "real(x)"
assert mcode(conjugate(x)) == "conj(x)"
assert mcode(chebyshevt(y, x)) == "chebyshevT(y, x)"
assert mcode(chebyshevu(y, x)) == "chebyshevU(y, x)"
assert mcode(laguerre(x, y)) == "laguerreL(x, y)"
assert mcode(Chi(x)) == "coshint(x)"
assert mcode(Shi(x)) == "sinhint(x)"
assert mcode(Ci(x)) == "cosint(x)"
assert mcode(Si(x)) == "sinint(x)"
assert mcode(li(x)) == "logint(x)"
assert mcode(loggamma(x)) == "gammaln(x)"
assert mcode(polygamma(x, y)) == "psi(x, y)"
assert mcode(RisingFactorial(x, y)) == "pochhammer(x, y)"
assert mcode(DiracDelta(x)) == "dirac(x)"
assert mcode(DiracDelta(x, 3)) == "dirac(3, x)"
assert mcode(Heaviside(x)) == "heaviside(x)"
assert mcode(Heaviside(x, y)) == "heaviside(x, y)"
def _get_const_characteristic_eq_sols(r, func, order):
r"""
Returns the roots of characteristic equation of constant coefficient
linear ODE and list of collectterms which is later on used by simplification
to use collect on solution.
The parameter `r` is a dict of order:coeff terms, where order is the order of the
derivative on each term, and coeff is the coefficient of that derivative.
"""
x = func.args[0]
# First, set up characteristic equation.
chareq, symbol = S.Zero, Dummy('x')
for i in r.keys():
if type(i) == str or i < 0:
pass
else:
chareq += r[i] * symbol**i
chareq = Poly(chareq, symbol)
# Can't just call roots because it doesn't return rootof for unsolveable
# polynomials.
chareqroots = roots(chareq, multiple=True)
if len(chareqroots) != order:
chareqroots = [rootof(chareq, k) for k in range(chareq.degree())]
chareq_is_complex = not all(i.is_real for i in chareq.all_coeffs())
# Create a dict root: multiplicity or charroots
charroots = defaultdict(int)
for root in chareqroots:
charroots[root] += 1
# We need to keep track of terms so we can run collect() at the end.
# This is necessary for constantsimp to work properly.
collectterms = []
gensols = []
conjugate_roots = [] # used to prevent double-use of conjugate roots
# Loop over roots in theorder provided by roots/rootof...
for root in chareqroots:
# but don't repoeat multiple roots.
if root not in charroots:
continue
multiplicity = charroots.pop(root)
for i in range(multiplicity):
if chareq_is_complex:
gensols.append(x**i * exp(root * x))
collectterms = [(i, root, 0)] + collectterms
continue
reroot = re(root)
imroot = im(root)
if imroot.has(atan2) and reroot.has(atan2):
# Remove this condition when re and im stop returning
# circular atan2 usages.
gensols.append(x**i * exp(root * x))
collectterms = [(i, root, 0)] + collectterms
else:
if root in conjugate_roots:
collectterms = [(i, reroot, imroot)] + collectterms
continue
if imroot == 0:
gensols.append(x**i * exp(reroot * x))
collectterms = [(i, reroot, 0)] + collectterms
continue
conjugate_roots.append(conjugate(root))
gensols.append(x**i * exp(reroot * x) * sin(abs(imroot) * x))
gensols.append(x**i * exp(reroot * x) * cos(imroot * x))
# This ordering is important
collectterms = [(i, reroot, imroot)] + collectterms
return gensols, collectterms
def reduce_rational_inequalities(exprs, gen, assume=True, relational=True):
"""Reduce a system of rational inequalities with rational coefficients.
Examples
========
>>> from sympy import Poly, Symbol
>>> from sympy.solvers.inequalities import reduce_rational_inequalities
>>> x = Symbol('x', real=True)
>>> reduce_rational_inequalities([[x**2 <= 0]], x)
x == 0
>>> reduce_rational_inequalities([[x + 2 > 0]], x)
And(-2 < x, x < oo)
>>> reduce_rational_inequalities([[(x + 2, ">")]], x)
And(-2 < x, x < oo)
>>> reduce_rational_inequalities([[x + 2]], x)
x == -2
"""
exact = True
eqs = []
for _exprs in exprs:
_eqs = []
for expr in _exprs:
if isinstance(expr, tuple):
expr, rel = expr
else:
if expr.is_Relational:
expr, rel = expr.lhs - expr.rhs, expr.rel_op
else:
expr, rel = expr, '=='
try:
(numer, denom), opt = parallel_poly_from_expr(
expr.together().as_numer_denom(), gen)
except PolynomialError:
raise PolynomialError("only polynomials and "
"rational functions are supported in this context")
if not opt.domain.is_Exact:
numer, denom, exact = numer.to_exact(), denom.to_exact(), False
domain = opt.domain.get_exact()
if not (domain.is_ZZ or domain.is_QQ):
raise NotImplementedError(
"inequality solving is not supported over %s" % opt.domain)
_eqs.append(((numer, denom), rel))
eqs.append(_eqs)
solution = solve_rational_inequalities(eqs)
if not exact:
solution = solution.evalf()
if not relational:
return solution
real = ask(Q.real(gen), assumptions=assume)
if not real:
result = And(solution.as_relational(re(gen)), Eq(im(gen), 0))
else:
result = solution.as_relational(gen)
return result
import sympy
from sympy.functions import im, re
import pystencils
from pystencils import AssignmentCollection
from pystencils.data_types import TypedSymbol, create_type
X, Y = pystencils.fields('x, y: complex64[2d]')
A, B = pystencils.fields('a, b: float32[2d]')
S1, S2, T = sympy.symbols('S1, S2, T')
TEST_ASSIGNMENTS = [
AssignmentCollection({X[0, 0]: 1j}),
AssignmentCollection({
S1: re(Y.center),
S2: im(Y.center),
X[0, 0]: 2j * S1 + S2
}),
AssignmentCollection({
A.center: re(Y.center),
B.center: im(Y.center),
}),
AssignmentCollection({
Y.center: re(Y.center) + X.center + 2j,
}),
AssignmentCollection({
T: 2 + 4j,
Y.center: X.center / T,
})
]
def reduce_rational_inequalities(exprs, gen, assume=True, relational=True):
"""Reduce a system of rational inequalities with rational coefficients.
Examples
========
>>> from sympy import Poly, Symbol
>>> from sympy.solvers.inequalities import reduce_rational_inequalities
>>> x = Symbol('x', real=True)
>>> reduce_rational_inequalities([[x**2 <= 0]], x)
x == 0
>>> reduce_rational_inequalities([[x + 2 > 0]], x)
-2 < x
"""
exact = True
eqs = []
for _exprs in exprs:
_eqs = []
for expr in _exprs:
if isinstance(expr, tuple):
expr, rel = expr
else:
if expr.is_Relational:
expr, rel = expr.lhs - expr.rhs, expr.rel_op
else:
expr, rel = expr, '=='
try:
(numer, denom), opt = parallel_poly_from_expr(expr.together().as_numer_denom(), gen)
except PolynomialError:
raise PolynomialError("only polynomials and rational functions are supported in this context")
if not opt.domain.is_Exact:
numer, denom, exact = numer.to_exact(), denom.to_exact(), False
domain = opt.domain.get_exact()
if not (domain.is_ZZ or domain.is_QQ):
raise NotImplementedError("inequality solving is not supported over %s" % opt.domain)
_eqs.append(((numer, denom), rel))
eqs.append(_eqs)
solution = solve_rational_inequalities(eqs)
if not exact:
solution = solution.evalf()
if not relational:
return solution
real = ask(Q.real(gen), assumptions=assume)
if not real:
result = And(solution.as_relational(re(gen)), Eq(im(gen), 0))
else:
result = solution.as_relational(gen)
return result
def test_complex():
x, y = symbols('x,y')
assert ask(Q.complex(x)) == None
assert ask(Q.complex(x), Q.complex(x)) == True
assert ask(Q.complex(x), Q.complex(y)) == None
assert ask(Q.complex(x), ~Q.complex(x)) == False
assert ask(Q.complex(x), Q.real(x)) == True
assert ask(Q.complex(x), ~Q.real(x)) == None
assert ask(Q.complex(x), Q.rational(x)) == True
assert ask(Q.complex(x), Q.irrational(x)) == True
assert ask(Q.complex(x), Q.positive(x)) == True
assert ask(Q.complex(x), Q.imaginary(x)) == True
# a+b
assert ask(Q.complex(x + 1), Q.complex(x)) == True
assert ask(Q.complex(x + 1), Q.real(x)) == True
assert ask(Q.complex(x + 1), Q.rational(x)) == True
assert ask(Q.complex(x + 1), Q.irrational(x)) == True
assert ask(Q.complex(x + 1), Q.imaginary(x)) == True
assert ask(Q.complex(x + 1), Q.integer(x)) == True
assert ask(Q.complex(x + 1), Q.even(x)) == True
assert ask(Q.complex(x + 1), Q.odd(x)) == True
assert ask(Q.complex(x + y), Q.complex(x) & Q.complex(y)) == True
assert ask(Q.complex(x + y), Q.real(x) & Q.imaginary(y)) == True
# a*x +b
assert ask(Q.complex(2 * x + 1), Q.complex(x)) == True
assert ask(Q.complex(2 * x + 1), Q.real(x)) == True
assert ask(Q.complex(2 * x + 1), Q.positive(x)) == True
assert ask(Q.complex(2 * x + 1), Q.rational(x)) == True
assert ask(Q.complex(2 * x + 1), Q.irrational(x)) == True
assert ask(Q.complex(2 * x + 1), Q.imaginary(x)) == True
assert ask(Q.complex(2 * x + 1), Q.integer(x)) == True
assert ask(Q.complex(2 * x + 1), Q.even(x)) == True
assert ask(Q.complex(2 * x + 1), Q.odd(x)) == True
# x**2
assert ask(Q.complex(x**2), Q.complex(x)) == True
assert ask(Q.complex(x**2), Q.real(x)) == True
assert ask(Q.complex(x**2), Q.positive(x)) == True
assert ask(Q.complex(x**2), Q.rational(x)) == True
assert ask(Q.complex(x**2), Q.irrational(x)) == True
assert ask(Q.complex(x**2), Q.imaginary(x)) == True
assert ask(Q.complex(x**2), Q.integer(x)) == True
assert ask(Q.complex(x**2), Q.even(x)) == True
assert ask(Q.complex(x**2), Q.odd(x)) == True
# 2**x
assert ask(Q.complex(2**x), Q.complex(x)) == True
assert ask(Q.complex(2**x), Q.real(x)) == True
assert ask(Q.complex(2**x), Q.positive(x)) == True
assert ask(Q.complex(2**x), Q.rational(x)) == True
assert ask(Q.complex(2**x), Q.irrational(x)) == True
assert ask(Q.complex(2**x), Q.imaginary(x)) == True
assert ask(Q.complex(2**x), Q.integer(x)) == True
assert ask(Q.complex(2**x), Q.even(x)) == True
assert ask(Q.complex(2**x), Q.odd(x)) == True
assert ask(Q.complex(x**y), Q.complex(x) & Q.complex(y)) == True
# trigonometric expressions
assert ask(Q.complex(sin(x))) == True
assert ask(Q.complex(sin(2 * x + 1))) == True
assert ask(Q.complex(cos(x))) == True
assert ask(Q.complex(cos(2 * x + 1))) == True
# exponential
assert ask(Q.complex(exp(x))) == True
assert ask(Q.complex(exp(x))) == True
# Q.complexes
assert ask(Q.complex(Abs(x))) == True
assert ask(Q.complex(re(x))) == True
assert ask(Q.complex(im(x))) == True
def test_complex():
x, y = symbols('xy')
assert ask(x, Q.complex) == None
assert ask(x, Q.complex, Assume(x, Q.complex)) == True
assert ask(x, Q.complex, Assume(y, Q.complex)) == None
assert ask(x, Q.complex, Assume(x, Q.complex, False)) == False
assert ask(x, Q.complex, Assume(x, Q.real)) == True
assert ask(x, Q.complex, Assume(x, Q.real, False)) == None
assert ask(x, Q.complex, Assume(x, Q.rational)) == True
assert ask(x, Q.complex, Assume(x, Q.irrational)) == True
assert ask(x, Q.complex, Assume(x, Q.positive)) == True
assert ask(x, Q.complex, Assume(x, Q.imaginary)) == True
# a+b
assert ask(x+1, Q.complex, Assume(x, Q.complex)) == True
assert ask(x+1, Q.complex, Assume(x, Q.real)) == True
assert ask(x+1, Q.complex, Assume(x, Q.rational)) == True
assert ask(x+1, Q.complex, Assume(x, Q.irrational)) == True
assert ask(x+1, Q.complex, Assume(x, Q.imaginary)) == True
assert ask(x+1, Q.complex, Assume(x, Q.integer)) == True
assert ask(x+1, Q.complex, Assume(x, Q.even)) == True
assert ask(x+1, Q.complex, Assume(x, Q.odd)) == True
assert ask(x+y, Q.complex, Assume(x, Q.complex) & Assume(y, Q.complex)) == True
assert ask(x+y, Q.complex, Assume(x, Q.real) & Assume(y, Q.imaginary)) == True
# a*x +b
assert ask(2*x+1, Q.complex, Assume(x, Q.complex)) == True
assert ask(2*x+1, Q.complex, Assume(x, Q.real)) == True
assert ask(2*x+1, Q.complex, Assume(x, Q.positive)) == True
assert ask(2*x+1, Q.complex, Assume(x, Q.rational)) == True
assert ask(2*x+1, Q.complex, Assume(x, Q.irrational)) == True
assert ask(2*x+1, Q.complex, Assume(x, Q.imaginary)) == True
assert ask(2*x+1, Q.complex, Assume(x, Q.integer)) == True
assert ask(2*x+1, Q.complex, Assume(x, Q.even)) == True
assert ask(2*x+1, Q.complex, Assume(x, Q.odd)) == True
# x**2
assert ask(x**2, Q.complex, Assume(x, Q.complex)) == True
assert ask(x**2, Q.complex, Assume(x, Q.real)) == True
assert ask(x**2, Q.complex, Assume(x, Q.positive)) == True
assert ask(x**2, Q.complex, Assume(x, Q.rational)) == True
assert ask(x**2, Q.complex, Assume(x, Q.irrational)) == True
assert ask(x**2, Q.complex, Assume(x, Q.imaginary)) == True
assert ask(x**2, Q.complex, Assume(x, Q.integer)) == True
assert ask(x**2, Q.complex, Assume(x, Q.even)) == True
assert ask(x**2, Q.complex, Assume(x, Q.odd)) == True
# 2**x
assert ask(2**x, Q.complex, Assume(x, Q.complex)) == True
assert ask(2**x, Q.complex, Assume(x, Q.real)) == True
assert ask(2**x, Q.complex, Assume(x, Q.positive)) == True
assert ask(2**x, Q.complex, Assume(x, Q.rational)) == True
assert ask(2**x, Q.complex, Assume(x, Q.irrational)) == True
assert ask(2**x, Q.complex, Assume(x, Q.imaginary)) == True
assert ask(2**x, Q.complex, Assume(x, Q.integer)) == True
assert ask(2**x, Q.complex, Assume(x, Q.even)) == True
assert ask(2**x, Q.complex, Assume(x, Q.odd)) == True
assert ask(x**y, Q.complex, Assume(x, Q.complex) & \
Assume(y, Q.complex)) == True
# trigonometric expressions
assert ask(sin(x), Q.complex) == True
assert ask(sin(2*x + 1), Q.complex) == True
assert ask(cos(x), Q.complex) == True
assert ask(cos(2*x+1), Q.complex) == True
# exponential
assert ask(exp(x), Q.complex) == True
assert ask(exp(x), Q.complex) == True
# Q.complexes
assert ask(Abs(x), Q.complex) == True
assert ask(re(x), Q.complex) == True
assert ask(im(x), Q.complex) == True
def _get_euler_characteristic_eq_sols(eq, func, match_obj):
r"""
Returns the solution of homogeneous part of the linear euler ODE and
the list of roots of characteristic equation.
The parameter ``match_obj`` is a dict of order:coeff terms, where order is the order
of the derivative on each term, and coeff is the coefficient of that derivative.
"""
x = func.args[0]
f = func.func
# First, set up characteristic equation.
chareq, symbol = S.Zero, Dummy('x')
for i in match_obj:
if i >= 0:
chareq += (match_obj[i] * diff(x**symbol, x, i) *
x**-symbol).expand()
chareq = Poly(chareq, symbol)
chareqroots = [rootof(chareq, k) for k in range(chareq.degree())]
collectterms = []
# A generator of constants
constants = list(get_numbered_constants(eq, num=chareq.degree() * 2))
constants.reverse()
# Create a dict root: multiplicity or charroots
charroots = defaultdict(int)
for root in chareqroots:
charroots[root] += 1
gsol = S.Zero
ln = log
for root, multiplicity in charroots.items():
for i in range(multiplicity):
if isinstance(root, RootOf):
gsol += (x**root) * constants.pop()
if multiplicity != 1:
raise ValueError("Value should be 1")
collectterms = [(0, root, 0)] + collectterms
elif root.is_real:
gsol += ln(x)**i * (x**root) * constants.pop()
collectterms = [(i, root, 0)] + collectterms
else:
reroot = re(root)
imroot = im(root)
gsol += ln(x)**i * (
x**reroot) * (constants.pop() * sin(abs(imroot) * ln(x)) +
constants.pop() * cos(imroot * ln(x)))
collectterms = [(i, reroot, imroot)] + collectterms
gsol = Eq(f(x), gsol)
gensols = []
# Keep track of when to use sin or cos for nonzero imroot
for i, reroot, imroot in collectterms:
if imroot == 0:
gensols.append(ln(x)**i * x**reroot)
else:
sin_form = ln(x)**i * x**reroot * sin(abs(imroot) * ln(x))
if sin_form in gensols:
cos_form = ln(x)**i * x**reroot * cos(imroot * ln(x))
gensols.append(cos_form)
else:
gensols.append(sin_form)
return gsol, gensols
def matrix_exp_jordan_form(A, t):
r"""
Matrix exponential $\exp(A*t)$ for the matrix *A* and scalar *t*.
Explanation
===========
Returns the Jordan form of the $\exp(A*t)$ along with the matrix $P$ such that:
.. math::
\exp(A*t) = P * expJ * P^{-1}
Examples
========
>>> from sympy import Matrix, Symbol
>>> from sympy.solvers.ode.systems import matrix_exp, matrix_exp_jordan_form
>>> t = Symbol('t')
We will consider a 2x2 defective matrix. This shows that our method
works even for defective matrices.
>>> A = Matrix([[1, 1], [0, 1]])
It can be observed that this function gives us the Jordan normal form
and the required invertible matrix P.
>>> P, expJ = matrix_exp_jordan_form(A, t)
Here, it is shown that P and expJ returned by this function is correct
as they satisfy the formula: P * expJ * P_inverse = exp(A*t).
>>> P * expJ * P.inv() == matrix_exp(A, t)
True
Parameters
==========
A : Matrix
The matrix $A$ in the expression $\exp(A*t)$
t : Symbol
The independent variable
References
==========
.. [1] https://en.wikipedia.org/wiki/Defective_matrix
.. [2] https://en.wikipedia.org/wiki/Jordan_matrix
.. [3] https://en.wikipedia.org/wiki/Jordan_normal_form
"""
N, M = A.shape
if N != M:
raise ValueError('Needed square matrix but got shape (%s, %s)' %
(N, M))
elif A.has(t):
raise ValueError('Matrix A should not depend on t')
def jordan_chains(A):
'''Chains from Jordan normal form analogous to M.eigenvects().
Returns a dict with eignevalues as keys like:
{e1: [[v111,v112,...], [v121, v122,...]], e2:...}
where vijk is the kth vector in the jth chain for eigenvalue i.
'''
P, blocks = A.jordan_cells()
basis = [P[:, i] for i in range(P.shape[1])]
n = 0
chains = {}
for b in blocks:
eigval = b[0, 0]
size = b.shape[0]
if eigval not in chains:
chains[eigval] = []
chains[eigval].append(basis[n:n + size])
n += size
return chains
eigenchains = jordan_chains(A)
# Needed for consistency across Python versions:
eigenchains_iter = sorted(eigenchains.items(), key=default_sort_key)
isreal = not A.has(I)
blocks = []
vectors = []
seen_conjugate = set()
for e, chains in eigenchains_iter:
for chain in chains:
n = len(chain)
if isreal and e != e.conjugate() and e.conjugate() in eigenchains:
if e in seen_conjugate:
continue
seen_conjugate.add(e.conjugate())
exprt = exp(re(e) * t)
imrt = im(e) * t
imblock = Matrix([[cos(imrt), sin(imrt)],
[-sin(imrt), cos(imrt)]])
expJblock2 = Matrix(
n, n, lambda i, j: imblock * t**(j - i) / factorial(j - i)
if j >= i else zeros(2, 2))
expJblock = Matrix(
2 * n, 2 * n,
lambda i, j: expJblock2[i // 2, j // 2][i % 2, j % 2])
blocks.append(exprt * expJblock)
for i in range(n):
vectors.append(re(chain[i]))
vectors.append(im(chain[i]))
else:
vectors.extend(chain)
fun = lambda i, j: t**(j - i) / factorial(j - i
) if j >= i else 0
expJblock = Matrix(n, n, fun)
blocks.append(exp(e * t) * expJblock)
expJ = Matrix.diag(*blocks)
P = Matrix(N, N, lambda i, j: vectors[j][i])
return P, expJ
def test_tensorflow_complexes():
assert tensorflow_code(re(x)) == "tensorflow.math.real(x)"
assert tensorflow_code(im(x)) == "tensorflow.math.imag(x)"
assert tensorflow_code(arg(x)) == "tensorflow.math.angle(x)"
def test_complex():
x, y = symbols('x,y')
assert ask(Q.complex(x)) == None
assert ask(Q.complex(x), Q.complex(x)) == True
assert ask(Q.complex(x), Q.complex(y)) == None
assert ask(Q.complex(x), ~Q.complex(x)) == False
assert ask(Q.complex(x), Q.real(x)) == True
assert ask(Q.complex(x), ~Q.real(x)) == None
assert ask(Q.complex(x), Q.rational(x)) == True
assert ask(Q.complex(x), Q.irrational(x)) == True
assert ask(Q.complex(x), Q.positive(x)) == True
assert ask(Q.complex(x), Q.imaginary(x)) == True
# a+b
assert ask(Q.complex(x+1), Q.complex(x)) == True
assert ask(Q.complex(x+1), Q.real(x)) == True
assert ask(Q.complex(x+1), Q.rational(x)) == True
assert ask(Q.complex(x+1), Q.irrational(x)) == True
assert ask(Q.complex(x+1), Q.imaginary(x)) == True
assert ask(Q.complex(x+1), Q.integer(x)) == True
assert ask(Q.complex(x+1), Q.even(x)) == True
assert ask(Q.complex(x+1), Q.odd(x)) == True
assert ask(Q.complex(x+y), Q.complex(x) & Q.complex(y)) == True
assert ask(Q.complex(x+y), Q.real(x) & Q.imaginary(y)) == True
# a*x +b
assert ask(Q.complex(2*x+1), Q.complex(x)) == True
assert ask(Q.complex(2*x+1), Q.real(x)) == True
assert ask(Q.complex(2*x+1), Q.positive(x)) == True
assert ask(Q.complex(2*x+1), Q.rational(x)) == True
assert ask(Q.complex(2*x+1), Q.irrational(x)) == True
assert ask(Q.complex(2*x+1), Q.imaginary(x)) == True
assert ask(Q.complex(2*x+1), Q.integer(x)) == True
assert ask(Q.complex(2*x+1), Q.even(x)) == True
assert ask(Q.complex(2*x+1), Q.odd(x)) == True
# x**2
assert ask(Q.complex(x**2), Q.complex(x)) == True
assert ask(Q.complex(x**2), Q.real(x)) == True
assert ask(Q.complex(x**2), Q.positive(x)) == True
assert ask(Q.complex(x**2), Q.rational(x)) == True
assert ask(Q.complex(x**2), Q.irrational(x)) == True
assert ask(Q.complex(x**2), Q.imaginary(x)) == True
assert ask(Q.complex(x**2), Q.integer(x)) == True
assert ask(Q.complex(x**2), Q.even(x)) == True
assert ask(Q.complex(x**2), Q.odd(x)) == True
# 2**x
assert ask(Q.complex(2**x), Q.complex(x)) == True
assert ask(Q.complex(2**x), Q.real(x)) == True
assert ask(Q.complex(2**x), Q.positive(x)) == True
assert ask(Q.complex(2**x), Q.rational(x)) == True
assert ask(Q.complex(2**x), Q.irrational(x)) == True
assert ask(Q.complex(2**x), Q.imaginary(x)) == True
assert ask(Q.complex(2**x), Q.integer(x)) == True
assert ask(Q.complex(2**x), Q.even(x)) == True
assert ask(Q.complex(2**x), Q.odd(x)) == True
assert ask(Q.complex(x**y), Q.complex(x) & Q.complex(y)) == True
# trigonometric expressions
assert ask(Q.complex(sin(x))) == True
assert ask(Q.complex(sin(2*x + 1))) == True
assert ask(Q.complex(cos(x))) == True
assert ask(Q.complex(cos(2*x+1))) == True
# exponential
assert ask(Q.complex(exp(x))) == True
assert ask(Q.complex(exp(x))) == True
# Q.complexes
assert ask(Q.complex(Abs(x))) == True
assert ask(Q.complex(re(x))) == True
assert ask(Q.complex(im(x))) == True
def roots_quintic(f):
"""
Calculate exact roots of a solvable quintic
"""
result = []
coeff_5, coeff_4, p, q, r, s = f.all_coeffs()
# Eqn must be of the form x^5 + px^3 + qx^2 + rx + s
if coeff_4:
return result
if coeff_5 != 1:
l = [p/coeff_5, q/coeff_5, r/coeff_5, s/coeff_5]
if not all(coeff.is_Rational for coeff in l):
return result
f = Poly(f/coeff_5)
quintic = PolyQuintic(f)
# Eqn standardized. Algo for solving starts here
if not f.is_irreducible:
return result
f20 = quintic.f20
# Check if f20 has linear factors over domain Z
if f20.is_irreducible:
return result
# Now, we know that f is solvable
for _factor in f20.factor_list()[1]:
if _factor[0].is_linear:
theta = _factor[0].root(0)
break
d = discriminant(f)
delta = sqrt(d)
# zeta = a fifth root of unity
zeta1, zeta2, zeta3, zeta4 = quintic.zeta
T = quintic.T(theta, d)
tol = S(1e-10)
alpha = T[1] + T[2]*delta
alpha_bar = T[1] - T[2]*delta
beta = T[3] + T[4]*delta
beta_bar = T[3] - T[4]*delta
disc = alpha**2 - 4*beta
disc_bar = alpha_bar**2 - 4*beta_bar
l0 = quintic.l0(theta)
l1 = _quintic_simplify((-alpha + sqrt(disc)) / S(2))
l4 = _quintic_simplify((-alpha - sqrt(disc)) / S(2))
l2 = _quintic_simplify((-alpha_bar + sqrt(disc_bar)) / S(2))
l3 = _quintic_simplify((-alpha_bar - sqrt(disc_bar)) / S(2))
order = quintic.order(theta, d)
test = (order*delta.n()) - ( (l1.n() - l4.n())*(l2.n() - l3.n()) )
# Comparing floats
if not comp(test, 0, tol):
l2, l3 = l3, l2
# Now we have correct order of l's
R1 = l0 + l1*zeta1 + l2*zeta2 + l3*zeta3 + l4*zeta4
R2 = l0 + l3*zeta1 + l1*zeta2 + l4*zeta3 + l2*zeta4
R3 = l0 + l2*zeta1 + l4*zeta2 + l1*zeta3 + l3*zeta4
R4 = l0 + l4*zeta1 + l3*zeta2 + l2*zeta3 + l1*zeta4
Res = [None, [None]*5, [None]*5, [None]*5, [None]*5]
Res_n = [None, [None]*5, [None]*5, [None]*5, [None]*5]
sol = Symbol('sol')
# Simplifying improves performance a lot for exact expressions
R1 = _quintic_simplify(R1)
R2 = _quintic_simplify(R2)
R3 = _quintic_simplify(R3)
R4 = _quintic_simplify(R4)
# Solve imported here. Causing problems if imported as 'solve'
# and hence the changed name
from sympy.solvers.solvers import solve as _solve
a, b = symbols('a b', cls=Dummy)
_sol = _solve( sol**5 - a - I*b, sol)
for i in range(5):
_sol[i] = factor(_sol[i])
R1 = R1.as_real_imag()
R2 = R2.as_real_imag()
R3 = R3.as_real_imag()
R4 = R4.as_real_imag()
for i, currentroot in enumerate(_sol):
Res[1][i] = _quintic_simplify(currentroot.subs({ a: R1[0], b: R1[1] }))
Res[2][i] = _quintic_simplify(currentroot.subs({ a: R2[0], b: R2[1] }))
Res[3][i] = _quintic_simplify(currentroot.subs({ a: R3[0], b: R3[1] }))
Res[4][i] = _quintic_simplify(currentroot.subs({ a: R4[0], b: R4[1] }))
for i in range(1, 5):
for j in range(5):
Res_n[i][j] = Res[i][j].n()
Res[i][j] = _quintic_simplify(Res[i][j])
r1 = Res[1][0]
r1_n = Res_n[1][0]
for i in range(5):
if comp(im(r1_n*Res_n[4][i]), 0, tol):
r4 = Res[4][i]
break
# Now we have various Res values. Each will be a list of five
# values. We have to pick one r value from those five for each Res
u, v = quintic.uv(theta, d)
testplus = (u + v*delta*sqrt(5)).n()
testminus = (u - v*delta*sqrt(5)).n()
# Evaluated numbers suffixed with _n
# We will use evaluated numbers for calculation. Much faster.
r4_n = r4.n()
r2 = r3 = None
for i in range(5):
r2temp_n = Res_n[2][i]
for j in range(5):
# Again storing away the exact number and using
# evaluated numbers in computations
r3temp_n = Res_n[3][j]
if (comp((r1_n*r2temp_n**2 + r4_n*r3temp_n**2 - testplus).n(), 0, tol) and
comp((r3temp_n*r1_n**2 + r2temp_n*r4_n**2 - testminus).n(), 0, tol)):
r2 = Res[2][i]
r3 = Res[3][j]
break
if r2:
break
# Now, we have r's so we can get roots
x1 = (r1 + r2 + r3 + r4)/5
x2 = (r1*zeta4 + r2*zeta3 + r3*zeta2 + r4*zeta1)/5
x3 = (r1*zeta3 + r2*zeta1 + r3*zeta4 + r4*zeta2)/5
x4 = (r1*zeta2 + r2*zeta4 + r3*zeta1 + r4*zeta3)/5
x5 = (r1*zeta1 + r2*zeta2 + r3*zeta3 + r4*zeta4)/5
result = [x1, x2, x3, x4, x5]
# Now check if solutions are distinct
saw = set()
for r in result:
r = r.n(2)
if r in saw:
# Roots were identical. Abort, return []
# and fall back to usual solve
return []
saw.add(r)
return result
def test_torch_complexes():
assert torch_code(re(x)) == "torch.real(x)"
assert torch_code(im(x)) == "torch.imag(x)"
assert torch_code(arg(x)) == "torch.angle(x)"