def test_other_symbol():
x = Symbol('x', integer=True)
assert x.is_integer is True
assert x.is_real is True
x = Symbol('x', integer=True, nonnegative=True)
assert x.is_integer is True
assert x.is_nonnegative is True
assert x.is_negative is False
assert x.is_positive is None
x = Symbol('x', integer=True, nonpositive=True)
assert x.is_integer is True
assert x.is_nonpositive is True
assert x.is_positive is False
assert x.is_negative is None
x = Symbol('x', odd=True)
assert x.is_odd is True
assert x.is_even is False
assert x.is_integer is True
x = Symbol('x', odd=False)
assert x.is_odd is False
assert x.is_even is None
assert x.is_integer is None
x = Symbol('x', even=True)
assert x.is_even is True
assert x.is_odd is False
assert x.is_integer is True
x = Symbol('x', even=False)
assert x.is_even is False
assert x.is_odd is None
assert x.is_integer is None
x = Symbol('x', integer=True, nonnegative=True)
assert x.is_integer is True
assert x.is_nonnegative is True
x = Symbol('x', integer=True, nonpositive=True)
assert x.is_integer is True
assert x.is_nonpositive is True
with raises(AttributeError):
x.is_real = False
def test_sanitize_assumptions():
# issue 6666
for cls in (Symbol, Dummy, Wild):
x = cls('x', real=1, positive=0)
assert x.is_real is True
assert x.is_positive is False
assert cls('', real=True, positive=None).is_positive is None
raises(ValueError, lambda: cls('', commutative=None))
raises(ValueError, lambda: Symbol._sanitize(dict(commutative=None)))
def test_global_dict():
global_dict = {'Symbol': Symbol}
inputs = {'Q & S': And(Symbol('Q'), Symbol('S'))}
for text, result in inputs.items():
assert parse_expr(text, global_dict=global_dict) == result
def test_issue_8642():
x = Symbol('x', real=True, integer=False)
assert (x * 2).is_integer is None
def test_issue_2920():
n = Symbol('n', negative=True)
assert sqrt(n).is_imaginary
def test_other_symbol():
x = Symbol('x', integer=True)
assert x.is_integer is True
assert x.is_real is True
x = Symbol('x', integer=True, nonnegative=True)
assert x.is_integer is True
assert x.is_nonnegative is True
assert x.is_negative is False
assert x.is_positive is None
x = Symbol('x', integer=True, nonpositive=True)
assert x.is_integer is True
assert x.is_nonpositive is True
assert x.is_positive is False
assert x.is_negative is None
x = Symbol('x', odd=True)
assert x.is_odd is True
assert x.is_even is False
assert x.is_integer is True
x = Symbol('x', odd=False)
assert x.is_odd is False
assert x.is_even is None
assert x.is_integer is None
x = Symbol('x', even=True)
assert x.is_even is True
assert x.is_odd is False
assert x.is_integer is True
x = Symbol('x', even=False)
assert x.is_even is False
assert x.is_odd is None
assert x.is_integer is None
x = Symbol('x', integer=True, nonnegative=True)
assert x.is_integer is True
assert x.is_nonnegative is True
x = Symbol('x', integer=True, nonpositive=True)
assert x.is_integer is True
assert x.is_nonpositive is True
with raises(AttributeError):
x.is_real = False
x = Symbol('x', algebraic=True)
assert x.is_transcendental is False
x = Symbol('x', transcendental=True)
assert x.is_algebraic is False
assert x.is_rational is False
assert x.is_integer is False
def test_issue1263():
neg = Symbol('neg', negative=True)
nonneg = Symbol('nonneg', negative=False)
any = Symbol('any')
num, den = sqrt(1 / neg).as_numer_denom()
assert num == sqrt(-1)
assert den == sqrt(-neg)
num, den = sqrt(1 / nonneg).as_numer_denom()
assert num == 1
assert den == sqrt(nonneg)
num, den = sqrt(1 / any).as_numer_denom()
assert num == sqrt(1 / any)
assert den == 1
def eqn(num, den, pow):
return (num / den)**pow
npos = 1
nneg = -1
dpos = 2 - sqrt(3)
dneg = 1 - sqrt(3)
I = S.ImaginaryUnit
assert dpos > 0 and dneg < 0 and npos > 0 and nneg < 0
# pos or neg integer
eq = eqn(npos, dpos, 2)
assert eq.is_Pow and eq.as_numer_denom() == (1, dpos**2)
eq = eqn(npos, dneg, 2)
assert eq.is_Pow and eq.as_numer_denom() == (1, dneg**2)
eq = eqn(nneg, dpos, 2)
assert eq.is_Pow and eq.as_numer_denom() == (1, dpos**2)
eq = eqn(nneg, dneg, 2)
assert eq.is_Pow and eq.as_numer_denom() == (1, dneg**2)
eq = eqn(npos, dpos, -2)
assert eq.is_Pow and eq.as_numer_denom() == (dpos**2, 1)
eq = eqn(npos, dneg, -2)
assert eq.is_Pow and eq.as_numer_denom() == (dneg**2, 1)
eq = eqn(nneg, dpos, -2)
assert eq.is_Pow and eq.as_numer_denom() == (dpos**2, 1)
eq = eqn(nneg, dneg, -2)
assert eq.is_Pow and eq.as_numer_denom() == (dneg**2, 1)
# pos or neg rational
pow = S.Half
eq = eqn(npos, dpos, pow)
assert eq.is_Pow and eq.as_numer_denom() == (npos**pow, dpos**pow)
eq = eqn(npos, dneg, pow)
assert eq.is_Pow and eq.as_numer_denom() == ((-npos)**pow, (-dneg)**pow)
eq = eqn(nneg, dpos, pow)
assert not eq.is_Pow or eq.as_numer_denom() == (nneg**pow, dpos**pow)
eq = eqn(nneg, dneg, pow)
assert eq.is_Pow and eq.as_numer_denom() == ((-nneg)**pow, (-dneg)**pow)
eq = eqn(npos, dpos, -pow)
assert eq.is_Pow and eq.as_numer_denom() == (dpos**pow, npos**pow)
eq = eqn(npos, dneg, -pow)
assert eq.is_Pow and eq.as_numer_denom() == ((-dneg)**pow, (-npos)**pow)
eq = eqn(nneg, dpos, -pow)
assert not eq.is_Pow or eq.as_numer_denom() == (dpos**pow, nneg**pow)
eq = eqn(nneg, dneg, -pow)
assert eq.is_Pow and eq.as_numer_denom() == ((-dneg)**pow, (-nneg)**pow)
# unknown exponent
pow = 2 * any
eq = eqn(npos, dpos, pow)
assert eq.is_Pow and eq.as_numer_denom() == (npos**pow, dpos**pow)
eq = eqn(npos, dneg, pow)
assert eq.is_Pow and eq.as_numer_denom() == (eq, 1)
eq = eqn(nneg, dpos, pow)
assert eq.is_Pow and eq.as_numer_denom() == (nneg**pow, dpos**pow)
eq = eqn(nneg, dneg, pow)
assert eq.is_Pow and eq.as_numer_denom() == ((-nneg)**pow, (-dneg)**pow)
eq = eqn(npos, dpos, -pow)
assert eq.as_numer_denom() == (dpos**pow, npos**pow)
eq = eqn(npos, dneg, -pow)
assert eq.is_Pow and eq.as_numer_denom() == (1, eq.base**pow)
eq = eqn(nneg, dpos, -pow)
assert eq.is_Pow and eq.as_numer_denom() == (dpos**pow, nneg**pow)
eq = eqn(nneg, dneg, -pow)
assert eq.is_Pow and eq.as_numer_denom() == ((-dneg)**pow, (-nneg)**pow)
x = Symbol('x')
assert ((1 / (1 + x / 3))**(-S.One)).as_numer_denom() == (3 + x, 3)
np = Symbol('np', positive=False)
assert (((1 + x / np)**-2)**(-S.One)).as_numer_denom() == ((np + x)**2,
np**2)
def test_expand():
x = Symbol('x')
assert (2**(-1 - x)).expand() == Rational(1, 2) * 2**(-x)
def test_dispersion():
x = Symbol("x")
a = Symbol("a")
fp = poly(S.Zero, x)
assert sorted(dispersionset(fp)) == [0]
fp = poly(S(2), x)
assert sorted(dispersionset(fp)) == [0]
fp = poly(x + 1, x)
assert sorted(dispersionset(fp)) == [0]
assert dispersion(fp) == 0
fp = poly((x + 1) * (x + 2), x)
assert sorted(dispersionset(fp)) == [0, 1]
assert dispersion(fp) == 1
fp = poly(x * (x + 3), x)
assert sorted(dispersionset(fp)) == [0, 3]
assert dispersion(fp) == 3
fp = poly((x - 3) * (x + 3), x)
assert sorted(dispersionset(fp)) == [0, 6]
assert dispersion(fp) == 6
fp = poly(x**4 - 3 * x**2 + 1, x)
gp = fp.shift(-3)
assert sorted(dispersionset(fp, gp)) == [2, 3, 4]
assert dispersion(fp, gp) == 4
assert sorted(dispersionset(gp, fp)) == []
assert dispersion(gp, fp) is -oo
fp = poly(x * (3 * x**2 + a) * (x - 2536) * (x**3 + a), x)
gp = fp.as_expr().subs(x, x - 345).as_poly(x)
assert sorted(dispersionset(fp, gp)) == [345, 2881]
assert sorted(dispersionset(gp, fp)) == [2191]
gp = poly((x - 2)**2 * (x - 3)**3 * (x - 5)**3, x)
assert sorted(dispersionset(gp)) == [0, 1, 2, 3]
assert sorted(dispersionset(gp, (gp + 4)**2)) == [1, 2]
fp = poly(x * (x + 2) * (x - 1), x)
assert sorted(dispersionset(fp)) == [0, 1, 2, 3]
fp = poly(x**2 + sqrt(5) * x - 1, x, domain="QQ<sqrt(5)>")
gp = poly(x**2 + (2 + sqrt(5)) * x + sqrt(5), x, domain="QQ<sqrt(5)>")
assert sorted(dispersionset(fp, gp)) == [2]
assert sorted(dispersionset(gp, fp)) == [1, 4]
# There are some difficulties if we compute over Z[a]
# and alpha happenes to lie in Z[a] instead of simply Z.
# Hence we can not decide if alpha is indeed integral
# in general.
fp = poly(
4 * x**4 + (4 * a + 8) * x**3 + (a**2 + 6 * a + 4) * x**2 +
(a**2 + 2 * a) * x,
x,
)
assert sorted(dispersionset(fp)) == [0, 1]
# For any specific value of a, the dispersion is 3*a
# but the algorithm can not find this in general.
# This is the point where the resultant based Ansatz
# is superior to the current one.
fp = poly(a**2 * x**3 + (a**3 + a**2 + a + 1) * x, x)
gp = fp.as_expr().subs(x, x - 3 * a).as_poly(x)
assert sorted(dispersionset(fp, gp)) == []
fpa = fp.as_expr().subs(a, 2).as_poly(x)
gpa = gp.as_expr().subs(a, 2).as_poly(x)
assert sorted(dispersionset(fpa, gpa)) == [6]
# Work with Expr instead of Poly
f = (x + 1) * (x + 2)
assert sorted(dispersionset(f)) == [0, 1]
assert dispersion(f) == 1
f = x**4 - 3 * x**2 + 1
g = x**4 - 12 * x**3 + 51 * x**2 - 90 * x + 55
assert sorted(dispersionset(f, g)) == [2, 3, 4]
assert dispersion(f, g) == 4
# Work with Expr and specify a generator
f = (x + 1) * (x + 2)
assert sorted(dispersionset(f, None, x)) == [0, 1]
assert dispersion(f, None, x) == 1
f = x**4 - 3 * x**2 + 1
g = x**4 - 12 * x**3 + 51 * x**2 - 90 * x + 55
assert sorted(dispersionset(f, g, x)) == [2, 3, 4]
assert dispersion(f, g, x) == 4
def test_issue_4362():
neg = Symbol('neg', negative=True)
nonneg = Symbol('nonneg', nonnegative=True)
any = Symbol('any')
num, den = sqrt(1 / neg).as_numer_denom()
assert num == sqrt(-1)
assert den == sqrt(-neg)
num, den = sqrt(1 / nonneg).as_numer_denom()
assert num == 1
assert den == sqrt(nonneg)
num, den = sqrt(1 / any).as_numer_denom()
assert num == sqrt(1 / any)
assert den == 1
def eqn(num, den, pow):
return (num / den)**pow
npos = 1
nneg = -1
dpos = 2 - sqrt(3)
dneg = 1 - sqrt(3)
assert dpos > 0 and dneg < 0 and npos > 0 and nneg < 0
# pos or neg integer
eq = eqn(npos, dpos, 2)
assert eq.is_Pow and eq.as_numer_denom() == (1, dpos**2)
eq = eqn(npos, dneg, 2)
assert eq.is_Pow and eq.as_numer_denom() == (1, dneg**2)
eq = eqn(nneg, dpos, 2)
assert eq.is_Pow and eq.as_numer_denom() == (1, dpos**2)
eq = eqn(nneg, dneg, 2)
assert eq.is_Pow and eq.as_numer_denom() == (1, dneg**2)
eq = eqn(npos, dpos, -2)
assert eq.is_Pow and eq.as_numer_denom() == (dpos**2, 1)
eq = eqn(npos, dneg, -2)
assert eq.is_Pow and eq.as_numer_denom() == (dneg**2, 1)
eq = eqn(nneg, dpos, -2)
assert eq.is_Pow and eq.as_numer_denom() == (dpos**2, 1)
eq = eqn(nneg, dneg, -2)
assert eq.is_Pow and eq.as_numer_denom() == (dneg**2, 1)
# pos or neg rational
pow = S.Half
eq = eqn(npos, dpos, pow)
assert eq.is_Pow and eq.as_numer_denom() == (npos**pow, dpos**pow)
eq = eqn(npos, dneg, pow)
assert eq.is_Pow is False and eq.as_numer_denom() == ((-npos)**pow,
(-dneg)**pow)
eq = eqn(nneg, dpos, pow)
assert not eq.is_Pow or eq.as_numer_denom() == (nneg**pow, dpos**pow)
eq = eqn(nneg, dneg, pow)
assert eq.is_Pow and eq.as_numer_denom() == ((-nneg)**pow, (-dneg)**pow)
eq = eqn(npos, dpos, -pow)
assert eq.is_Pow and eq.as_numer_denom() == (dpos**pow, npos**pow)
eq = eqn(npos, dneg, -pow)
assert eq.is_Pow is False and eq.as_numer_denom() == (-(-npos)**pow *
(-dneg)**pow, npos)
eq = eqn(nneg, dpos, -pow)
assert not eq.is_Pow or eq.as_numer_denom() == (dpos**pow, nneg**pow)
eq = eqn(nneg, dneg, -pow)
assert eq.is_Pow and eq.as_numer_denom() == ((-dneg)**pow, (-nneg)**pow)
# unknown exponent
pow = 2 * any
eq = eqn(npos, dpos, pow)
assert eq.is_Pow and eq.as_numer_denom() == (npos**pow, dpos**pow)
eq = eqn(npos, dneg, pow)
assert eq.is_Pow and eq.as_numer_denom() == ((-npos)**pow, (-dneg)**pow)
eq = eqn(nneg, dpos, pow)
assert eq.is_Pow and eq.as_numer_denom() == (nneg**pow, dpos**pow)
eq = eqn(nneg, dneg, pow)
assert eq.is_Pow and eq.as_numer_denom() == ((-nneg)**pow, (-dneg)**pow)
eq = eqn(npos, dpos, -pow)
assert eq.as_numer_denom() == (dpos**pow, npos**pow)
eq = eqn(npos, dneg, -pow)
assert eq.is_Pow and eq.as_numer_denom() == ((-dneg)**pow, (-npos)**pow)
eq = eqn(nneg, dpos, -pow)
assert eq.is_Pow and eq.as_numer_denom() == (dpos**pow, nneg**pow)
eq = eqn(nneg, dneg, -pow)
assert eq.is_Pow and eq.as_numer_denom() == ((-dneg)**pow, (-nneg)**pow)
x = Symbol('x')
y = Symbol('y')
assert ((1 / (1 + x / 3))**(-S.One)).as_numer_denom() == (3 + x, 3)
notp = Symbol('notp', positive=False) # not positive does not imply real
b = ((1 + x / notp)**-2)
assert (b**(-y)).as_numer_denom() == (1, b**y)
assert (b**(-S.One)).as_numer_denom() == ((notp + x)**2, notp**2)
nonp = Symbol('nonp', nonpositive=True)
assert (((1 + x / nonp)**-2)**(-S.One)).as_numer_denom() == ((-nonp -
x)**2,
nonp**2)
n = Symbol('n', negative=True)
assert (x**n).as_numer_denom() == (1, x**-n)
assert sqrt(1 / n).as_numer_denom() == (S.ImaginaryUnit, sqrt(-n))
n = Symbol('0 or neg', nonpositive=True)
# if x and n are split up without negating each term and n is negative
# then the answer might be wrong; if n is 0 it won't matter since
# 1/oo and 1/zoo are both zero as is sqrt(0)/sqrt(-x) unless x is also
# zero (in which case the negative sign doesn't matter):
# 1/sqrt(1/-1) = -I but sqrt(-1)/sqrt(1) = I
assert (1 / sqrt(x / n)).as_numer_denom() == (sqrt(-n), sqrt(-x))
c = Symbol('c', complex=True)
e = sqrt(1 / c)
assert e.as_numer_denom() == (e, 1)
i = Symbol('i', integer=True)
assert ((1 + x / y)**i).as_numer_denom() == ((x + y)**i, y**i)
def test_expand():
x = Symbol('x')
assert (2**(-1 - x)).expand() == S.Half * 2**(-x)
def test_issue_8650():
n = Symbol('n', integer=True, nonnegative=True)
assert (n**n).is_positive is True
x = 5 * n + 5
assert (x**(5 * (n + 1))).is_positive is True
def test_issue_6653():
x = Symbol('x')
assert (1 / sqrt(1 + sin(x**2))).series(x, 0, 3) == 1 - x**2 / 2 + O(x**3)
def test_issue_6782():
x = Symbol('x')
assert sqrt(sin(x**3)).series(x, 0, 7) == x**Rational(3, 2) + O(x**7)
assert sqrt(sin(x**4)).series(x, 0, 3) == x**2 + O(x**3)
def test_issue_6990():
x = Symbol('x')
a = Symbol('a')
b = Symbol('b')
assert (sqrt(a + b*x + x**2)).series(x, 0, 3).removeO() == \
sqrt(a)*x**2*(1/(2*a) - b**2/(8*a**2)) + sqrt(a) + b*x/(2*sqrt(a))
def lagrange(it_num, datadir, doprint, direct):
'''
This code applies Lagrange's method and calculates minimum based on the
methodology elaborated in the TEA theory document in Section (3). Equations in
this code contain both references and an explicitly written definitions.
The program reads the last iteration's output and data from the last header
file, creates variables for the Lagrange equations, sets up the Lagrange
equations, and calculates final x_i mole numbers for the current iteration
cycle. Note that the mole numbers that result from this function are
allowed to be negative. If negatives are returned, lambda correction
(lambdacorr.py) is necessary. The final x_i values, as well as x_bar,
y_bar, delta, and delta_bar are written into machine- and human-readable
output files. This function is executed by iterate.py.
Parameters
----------
it_num: integer
Iteration number.
datadir: string
Current directory where TEA is run.
doprint: string
Parameter in configuration file that allows printing for
debugging purposes.
direct: object
Object containing all of the results/data from the previous
calculation in lagrange.py or lambdacorr.py. It is a list
containing current header directory, current iteration
number, array of species names, array of initial guess,
array of non-corrected Lagrange values, and array of
lambdacorr corrected values.
Returns
-------
header: string
Name of the header file used.
it_num: integer
Iteration number.
speclist: string array
Array containing names of molecular species.
y: float array
Array containing initial guess of molecular species for
current iteration.
x: float array
Array containing final mole numbers of molecular species for
current iteration.
delta: float array
Array containing change in initial and final mole numbers of
molecular species for current iteration.
y_bar: float
Array containing total sum of initial guesses of all molecular
species for current iteration.
x_bar: float
Total sum of the final mole numbers of all molecular species.
delta_bar: float
Change in total of initial and final mole numbers of molecular
species.
'''
# Read values from last iteration
input = direct
# Take the current header file
header = input[0]
# Read values from the header file
pressure, temp, i, j, speclist, a, b, g_RT = form.readheader(header)
# Use final values from last iteration (x values) as new initial
y = input[4]
y_bar = input[7]
# Perform checks to be safe
it_num_check = input[1]
speclist_check = input[2]
# Make array of checks
check = np.array([it_num_check != it_num - 1,
False in (speclist_check == speclist) ])
# If iteration number given by iterate.py is not one larger as in 'direct',
# give error
if check[0]:
print("\n\nMAJOR ERROR! Read in file's it_num is not the most \
recent iteration!\n\n")
# If species names in the header are not the same as in 'direct',
# give error
if check[1]:
print("\n\nMAJOR ERROR! Read in file uses different species \
order/list!\n\n")
# ============== CREATE VARIABLES FOR LAGRANGE EQUATION ============== #
# Create 'c' value, equation (18) TEA theory document
# ci = (g/RT)_i + ln(P)
c = g_RT + np.log(pressure)
# Allocates array of fi(Y) over different values of i (species)
fi_y = np.zeros(i)
# Fill in fi(Y) values equation (19) TEA theory document
# fi = x_i * [ci + ln(x_i/x_bar)]
for n in np.arange(i):
y_frac = np.float(y[n] / y_bar)
fi_y[n] = y[n] * ( c[n] + np.log(y_frac) )
# Allocate values of rjk. Both j and k goes from 1 to m.
k = j
rjk = np.zeros((j,k))
# Fill out values of rjk, equation (26) TEA theory document
# rjk = rkj = sum_i(a_ij * a_ik) * y_i
for l in np.arange(k):
for m in np.arange(j):
r_sum = 0.0
for n in np.arange(i):
r_sum += a[n, m] * a[n, l] * y[n]
rjk[m, l] = r_sum
# Allocate value of u, equation (28) TEA theory document
u = Symbol('u')
# Allocate pi_j variables, where j is element index
# Example: pi_2 is Lagrange multiplier of N (j = 2)
pi = []
for m in np.arange(j):
name = 'pi_' + np.str(m+1)
pi = np.append(pi, Symbol(name))
# Allocate rjk * pi_j summations, equation (27) TEA theory document
# There will be j * k terms of rjk * pi_j
sq_pi = [pi]
for m in np.arange(j-1):
# Make square array of pi values with shape j * k
sq_pi = np.append(sq_pi, [pi], axis = 0)
# Multiply rjk * sq_pi to get array of rjk * pi_j
# equation (27) TEA theory document
rpi = rjk * sq_pi
# ======================= SET FINAL EQUATIONS ======================= #
# Total number of equations is j + 1
# Set up a_ij * fi(Y) summations equation (27) TEA theory document
# sum_i[a_ij * fi(Y)]
aij_fiy = np.zeros((j))
for m in np.arange(j):
rhs = 0.0
for n in np.arange(i):
rhs += a[n,m] * fi_y[n]
aij_fiy[m] = rhs
# Create first j'th equations equation (27) TEA theory document
# r_1m*pi_1 + r_2m*pi_2 + ... + r_mm*pi_m + b_m*u = sum_i[a_im * fi(Y)]
for m in np.arange(j):
if m == 0:
equations = np.array([np.sum(rpi[m]) + b[m]*u - aij_fiy[m]])
else:
lagrange_eq = np.array([np.sum(rpi[m]) + b[m]*u - aij_fiy[m]])
equations = np.append(equations, lagrange_eq)
# Last (j+1)th equation (27) TEA theory document
# b_1*pi_1 + b_2*pi_2 + ... + b_m*pi_m + 0*u = sum_i[fi(Y)]
bpi = b * pi
lagrange_eq_last = np.array([np.sum(bpi) - np.sum(fi_y)])
equations = np.append(equations, lagrange_eq_last)
# List all unknowns in the above set of equations
unknowns = list(pi)
unknowns.append(u)
# Solve final system of j+1 equations
fsol = solve(list(equations), unknowns, rational=False)
# ============ CALCULATE xi VALUES FOR CURRENT ITERATION ============ #
# Make array of pi values
pi_f = []
for m in np.arange(j):
pi_f = np.append(pi_f, [fsol[pi[m]]])
# Calculate x_bar from solution to get 'u', equation (28) TEA theory document
# u = -1. + (x_bar/y_bar)
u_f = fsol[u]
x_bar = (u_f + 1.) * y_bar
# Initiate array for x values of size i
x = np.zeros(i)
# Apply Lagrange solution for final set of x_i values for this iteration
# equation (23) TEA theory document
# x_i = -fi(Y) + (y_i/y_bar) * x_bar + [sum_j(pi_j * a_ij)] * y_i
for n in np.arange(i):
sum_pi_aij = 0.0
for m in np.arange(j):
sum_pi_aij += pi_f[m] * a[n, m]
x[n] = - fi_y[n] + (y[n]/y_bar) * x_bar + sum_pi_aij * y[n]
# Calculate other variables of interest
x_bar = np.sum(x) # sum of all x_i
delta = x - y # difference between initial and final values
delta_bar = x_bar - y_bar # difference between sum of initial and
# final values
# Name output files with corresponding iteration number name
file = datadir + '/lagrange-iteration-' + np.str(it_num) + \
'machine-read-nocorr.txt'
file_fancy = datadir + '/lagrange-iteration-' + np.str(it_num) + \
'-visual-nocorr.txt'
# Export all values into machine and human readable output files
form.output(datadir, header, it_num, speclist, y, x, \
delta, y_bar, x_bar, delta_bar, file, doprint)
form.fancyout(datadir, it_num, speclist, y, x, delta,\
y_bar, x_bar, delta_bar, file_fancy, doprint)
return [header, it_num, speclist, y, x, delta, y_bar, x_bar, delta_bar]
def test_issue_7663():
x = Symbol('x')
e = '2*(x+1)'
assert parse_expr(e, evaluate=0) == parse_expr(e, evaluate=False)
assert parse_expr(e, evaluate=0).equals(2 * (x + 1))
def test_power_with_noncommutative_mul_as_base():
x = Symbol('x', commutative=False)
y = Symbol('y', commutative=False)
assert not (x * y)**3 == x**3 * y**3
assert (2 * x * y)**3 == 8 * (x * y)**3
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 test_negative_one():
x = Symbol('x', complex=True)
y = Symbol('y', complex=True)
assert 1 / x**y == x**(-y)
def test_parse_function_issue_3539():
x = Symbol('x')
f = Function('f')
assert parse_expr('f(x)') == f(x)
def test_issue_9165():
z = Symbol('z', zero=True)
f = Symbol('f', finite=False)
assert 0 / z == S.NaN
assert 0 * (1 / z) == S.NaN
assert 0 * f == S.NaN
def test_unicode_names():
assert parse_expr('α') == Symbol('α')
def test_inconsistent():
# cf. issues 5795 and 5545
raises(InconsistentAssumptions,
lambda: Symbol('x', real=True, commutative=False))
def __new__(cls, domain, codomain, name):
if not name:
raise ValueError("Empty morphism names not allowed.")
return Basic.__new__(cls, domain, codomain, Symbol(name))
def test_issue_7899():
x = Symbol('x', real=True)
assert (I * x).is_real is None
assert ((x - I) * (x - 1)).is_zero is None
assert ((x - I) * (x - 1)).is_real is None
from mpmath import bernfrac, workprec
from mpmath.libmp import ifib as _ifib
def _product(a, b):
p = 1
for k in xrange(a, b + 1):
p *= k
return p
from sympy.utilities.memoization import recurrence_memo
# Dummy symbol used for computing polynomial sequences
_sym = Symbol('x')
_symbols = Function('x')
#----------------------------------------------------------------------------#
# #
# Fibonacci numbers #
# #
#----------------------------------------------------------------------------#
class fibonacci(Function):
r"""
Fibonacci numbers / Fibonacci polynomials
The Fibonacci numbers are the integer sequence defined by the
initial terms F_0 = 0, F_1 = 1 and the two-term recurrence
def solve_univariate_inequality(expr,
gen,
relational=True,
domain=S.Reals,
continuous=False):
"""Solves a real univariate inequality.
Parameters
==========
expr : Relational
The target inequality
gen : Symbol
The variable for which the inequality is solved
relational : bool
A Relational type output is expected or not
domain : Set
The domain over which the equation is solved
continuous: bool
True if expr is known to be continuous over the given domain
(and so continuous_domain() doesn't need to be called on it)
Raises
======
NotImplementedError
The solution of the inequality cannot be determined due to limitation
in :func:`sympy.solvers.solveset.solvify`.
Notes
=====
Currently, we cannot solve all the inequalities due to limitations in
:func:`sympy.solvers.solveset.solvify`. Also, the solution returned for trigonometric inequalities
are restricted in its periodic interval.
See Also
========
sympy.solvers.solveset.solvify: solver returning solveset solutions with solve's output API
Examples
========
>>> from sympy.solvers.inequalities import solve_univariate_inequality
>>> from sympy import Symbol, sin, Interval, S
>>> x = Symbol('x')
>>> solve_univariate_inequality(x**2 >= 4, x)
((2 <= x) & (x < oo)) | ((x <= -2) & (-oo < x))
>>> solve_univariate_inequality(x**2 >= 4, x, relational=False)
Union(Interval(-oo, -2), Interval(2, oo))
>>> domain = Interval(0, S.Infinity)
>>> solve_univariate_inequality(x**2 >= 4, x, False, domain)
Interval(2, oo)
>>> solve_univariate_inequality(sin(x) > 0, x, relational=False)
Interval.open(0, pi)
"""
from sympy import im
from sympy.calculus.util import (continuous_domain, periodicity,
function_range)
from sympy.solvers.solvers import denoms
from sympy.solvers.solveset import solvify, solveset
# This keeps the function independent of the assumptions about `gen`.
# `solveset` makes sure this function is called only when the domain is
# real.
_gen = gen
_domain = domain
if gen.is_extended_real is False:
rv = S.EmptySet
return rv if not relational else rv.as_relational(_gen)
elif gen.is_extended_real is None:
gen = Dummy('gen', extended_real=True)
try:
expr = expr.xreplace({_gen: gen})
except TypeError:
raise TypeError(
filldedent('''
When gen is real, the relational has a complex part
which leads to an invalid comparison like I < 0.
'''))
rv = None
if expr is S.true:
rv = domain
elif expr is S.false:
rv = S.EmptySet
else:
e = expr.lhs - expr.rhs
period = periodicity(e, gen)
if period == S.Zero:
e = expand_mul(e)
const = expr.func(e, 0)
if const is S.true:
rv = domain
elif const is S.false:
rv = S.EmptySet
elif period is not None:
frange = function_range(e, gen, domain)
rel = expr.rel_op
if rel == '<' or rel == '<=':
if expr.func(frange.sup, 0):
rv = domain
elif not expr.func(frange.inf, 0):
rv = S.EmptySet
elif rel == '>' or rel == '>=':
if expr.func(frange.inf, 0):
rv = domain
elif not expr.func(frange.sup, 0):
rv = S.EmptySet
inf, sup = domain.inf, domain.sup
if sup - inf is S.Infinity:
domain = Interval(0, period, False, True)
if rv is None:
n, d = e.as_numer_denom()
try:
if gen not in n.free_symbols and len(e.free_symbols) > 1:
raise ValueError
# this might raise ValueError on its own
# or it might give None...
solns = solvify(e, gen, domain)
if solns is None:
# in which case we raise ValueError
raise ValueError
except (ValueError, NotImplementedError):
# replace gen with generic x since it's
# univariate anyway
raise NotImplementedError(
filldedent('''
The inequality, %s, cannot be solved using
solve_univariate_inequality.
''' % expr.subs(gen, Symbol('x'))))
expanded_e = expand_mul(e)
def valid(x):
# this is used to see if gen=x satisfies the
# relational by substituting it into the
# expanded form and testing against 0, e.g.
# if expr = x*(x + 1) < 2 then e = x*(x + 1) - 2
# and expanded_e = x**2 + x - 2; the test is
# whether a given value of x satisfies
# x**2 + x - 2 < 0
#
# expanded_e, expr and gen used from enclosing scope
v = expanded_e.subs(gen, expand_mul(x))
try:
r = expr.func(v, 0)
except TypeError:
r = S.false
if r in (S.true, S.false):
return r
if v.is_extended_real is False:
return S.false
else:
v = v.n(2)
if v.is_comparable:
return expr.func(v, 0)
# not comparable or couldn't be evaluated
raise NotImplementedError(
'relationship did not evaluate: %s' % r)
singularities = []
for d in denoms(expr, gen):
singularities.extend(solvify(d, gen, domain))
if not continuous:
domain = continuous_domain(expanded_e, gen, domain)
include_x = '=' in expr.rel_op and expr.rel_op != '!='
try:
discontinuities = set(domain.boundary -
FiniteSet(domain.inf, domain.sup))
# remove points that are not between inf and sup of domain
critical_points = FiniteSet(
*(solns + singularities +
list(discontinuities))).intersection(
Interval(domain.inf, domain.sup, domain.inf
not in domain, domain.sup not in domain))
if all(r.is_number for r in critical_points):
reals = _nsort(critical_points, separated=True)[0]
else:
sifted = sift(critical_points,
lambda x: x.is_extended_real)
if sifted[None]:
# there were some roots that weren't known
# to be real
raise NotImplementedError
try:
reals = sifted[True]
if len(reals) > 1:
reals = list(sorted(reals))
except TypeError:
raise NotImplementedError
except NotImplementedError:
raise NotImplementedError(
'sorting of these roots is not supported')
# If expr contains imaginary coefficients, only take real
# values of x for which the imaginary part is 0
make_real = S.Reals
if im(expanded_e) != S.Zero:
check = True
im_sol = FiniteSet()
try:
a = solveset(im(expanded_e), gen, domain)
if not isinstance(a, Interval):
for z in a:
if z not in singularities and valid(
z) and z.is_extended_real:
im_sol += FiniteSet(z)
else:
start, end = a.inf, a.sup
for z in _nsort(critical_points + FiniteSet(end)):
valid_start = valid(start)
if start != end:
valid_z = valid(z)
pt = _pt(start, z)
if pt not in singularities and pt.is_extended_real and valid(
pt):
if valid_start and valid_z:
im_sol += Interval(start, z)
elif valid_start:
im_sol += Interval.Ropen(start, z)
elif valid_z:
im_sol += Interval.Lopen(start, z)
else:
im_sol += Interval.open(start, z)
start = z
for s in singularities:
im_sol -= FiniteSet(s)
except (TypeError):
im_sol = S.Reals
check = False
if isinstance(im_sol, EmptySet):
raise ValueError(
filldedent('''
%s contains imaginary parts which cannot be
made 0 for any value of %s satisfying the
inequality, leading to relations like I < 0.
''' % (expr.subs(gen, _gen), _gen)))
make_real = make_real.intersect(im_sol)
sol_sets = [S.EmptySet]
start = domain.inf
if valid(start) and start.is_finite:
sol_sets.append(FiniteSet(start))
for x in reals:
end = x
if valid(_pt(start, end)):
sol_sets.append(Interval(start, end, True, True))
if x in singularities:
singularities.remove(x)
else:
if x in discontinuities:
discontinuities.remove(x)
_valid = valid(x)
else: # it's a solution
_valid = include_x
if _valid:
sol_sets.append(FiniteSet(x))
start = end
end = domain.sup
if valid(end) and end.is_finite:
sol_sets.append(FiniteSet(end))
if valid(_pt(start, end)):
sol_sets.append(Interval.open(start, end))
if im(expanded_e) != S.Zero and check:
rv = (make_real).intersect(_domain)
else:
rv = Intersection((Union(*sol_sets)), make_real,
_domain).subs(gen, _gen)
return rv if not relational else rv.as_relational(_gen)
from sympy.core import Function, Symbol
from sympy.functions import airyai, airybi, besselj, bessely
from sympy.integrals.risch import NonElementaryIntegral
from sympy.solvers.ode import classify_ode, dsolve
from sympy.solvers.ode.ode import allhints, _remove_redundant_solutions
from sympy.solvers.ode.single import (FirstLinear, ODEMatchError,
SingleODEProblem, SingleODESolver)
from sympy.solvers.ode.subscheck import checkodesol
from sympy.testing.pytest import raises, slow
import traceback
x = Symbol('x')
u = Symbol('u')
y = Symbol('y')
f = Function('f')
g = Function('g')
C1, C2, C3, C4, C5 = symbols('C1:6')
hint_message = """\
Hint did not match the example {example}.
The ODE is:
{eq}.
The expected hint was
{our_hint}\
def test_other_symbol():
x = Symbol("x", integer=True)
assert x.is_integer is True
assert x.is_real is True
x = Symbol("x", integer=True, nonnegative=True)
assert x.is_integer is True
assert x.is_nonnegative is True
assert x.is_negative is False
assert x.is_positive is None
x = Symbol("x", integer=True, nonpositive=True)
assert x.is_integer is True
assert x.is_nonpositive is True
assert x.is_positive is False
assert x.is_negative is None
x = Symbol("x", odd=True)
assert x.is_odd is True
assert x.is_even is False
assert x.is_integer is True
x = Symbol("x", odd=False)
assert x.is_odd is False
assert x.is_even is None
assert x.is_integer is None
x = Symbol("x", even=True)
assert x.is_even is True
assert x.is_odd is False
assert x.is_integer is True
x = Symbol("x", even=False)
assert x.is_even is False
assert x.is_odd is None
assert x.is_integer is None
x = Symbol("x", integer=True, nonnegative=True)
assert x.is_integer is True
assert x.is_nonnegative is True
x = Symbol("x", integer=True, nonpositive=True)
assert x.is_integer is True
assert x.is_nonpositive is True
with raises(AttributeError):
x.is_real = False
x = Symbol("x", algebraic=True)
assert x.is_transcendental is False
x = Symbol("x", transcendental=True)
assert x.is_algebraic is False
assert x.is_rational is False
assert x.is_integer is False
def _get_examples_ode_sol_separable():
# test_separable1-5 are from Ordinary Differential Equations, Tenenbaum and
# Pollard, pg. 55
a = Symbol('a')
return {
'hint': "separable",
'func': f(x),
'examples':{
'separable_01': {
'eq': f(x).diff(x) - f(x),
'sol': [Eq(f(x), C1*exp(x))],
},
'separable_02': {
'eq': x*f(x).diff(x) - f(x),
'sol': [Eq(f(x), C1*x)],
},
'separable_03': {
'eq': f(x).diff(x) + sin(x),
'sol': [Eq(f(x), C1 + cos(x))],
},
'separable_04': {
'eq': f(x)**2 + 1 - (x**2 + 1)*f(x).diff(x),
'sol': [Eq(f(x), tan(C1 + atan(x)))],
},
'separable_05': {
'eq': f(x).diff(x)/tan(x) - f(x) - 2,
'sol': [Eq(f(x), C1/cos(x) - 2)],
},
'separable_06': {
'eq': f(x).diff(x) * (1 - sin(f(x))) - 1,
'sol': [Eq(-x + f(x) + cos(f(x)), C1)],
},
'separable_07': {
'eq': f(x)*x**2*f(x).diff(x) - f(x)**3 - 2*x**2*f(x).diff(x),
'sol': [Eq(f(x), (-x + sqrt(x*(4*C1*x + x - 4)))/(C1*x - 1)/2),
Eq(f(x), -((x + sqrt(x*(4*C1*x + x - 4)))/(C1*x - 1))/2)],
'slow': True,
},
'separable_08': {
'eq': f(x)**2 - 1 - (2*f(x) + x*f(x))*f(x).diff(x),
'sol': [Eq(f(x), -sqrt(C1*x**2 + 4*C1*x + 4*C1 + 1)),
Eq(f(x), sqrt(C1*x**2 + 4*C1*x + 4*C1 + 1))],
'slow': True,
},
'separable_09': {
'eq': x*log(x)*f(x).diff(x) + sqrt(1 + f(x)**2),
'sol': [Eq(f(x), sinh(C1 - log(log(x))))], #One more solution is f(x)=I
'slow': True,
'checkodesol_XFAIL': True,
},
'separable_10': {
'eq': exp(x + 1)*tan(f(x)) + cos(f(x))*f(x).diff(x),
'sol': [Eq(E*exp(x) + log(cos(f(x)) - 1)/2 - log(cos(f(x)) + 1)/2 + cos(f(x)), C1)],
'slow': True,
},
'separable_11': {
'eq': (x*cos(f(x)) + x**2*sin(f(x))*f(x).diff(x) - a**2*sin(f(x))*f(x).diff(x)),
'sol': [Eq(f(x), -acos(C1*sqrt(-a**2 + x**2)) + 2*pi),
Eq(f(x), acos(C1*sqrt(-a**2 + x**2)))],
'slow': True,
},
'separable_12': {
'eq': f(x).diff(x) - f(x)*tan(x),
'sol': [Eq(f(x), C1/cos(x))],
},
'separable_13': {
'eq': (x - 1)*cos(f(x))*f(x).diff(x) - 2*x*sin(f(x)),
'sol': [Eq(f(x), pi - asin(C1*(x**2 - 2*x + 1)*exp(2*x))),
Eq(f(x), asin(C1*(x**2 - 2*x + 1)*exp(2*x)))],
},
'separable_14': {
'eq': f(x).diff(x) - f(x)*log(f(x))/tan(x),
'sol': [Eq(f(x), exp(C1*sin(x)))],
},
'separable_15': {
'eq': x*f(x).diff(x) + (1 + f(x)**2)*atan(f(x)),
'sol': [Eq(f(x), tan(C1/x))], #Two more solutions are f(x)=0 and f(x)=I
'slow': True,
'checkodesol_XFAIL': True,
},
'separable_16': {
'eq': f(x).diff(x) + x*(f(x) + 1),
'sol': [Eq(f(x), -1 + C1*exp(-x**2/2))],
},
'separable_17': {
'eq': exp(f(x)**2)*(x**2 + 2*x + 1) + (x*f(x) + f(x))*f(x).diff(x),
'sol': [Eq(f(x), -sqrt(log(1/(C1 + x**2 + 2*x)))),
Eq(f(x), sqrt(log(1/(C1 + x**2 + 2*x))))],
},
'separable_18': {
'eq': f(x).diff(x) + f(x),
'sol': [Eq(f(x), C1*exp(-x))],
},
'separable_19': {
'eq': sin(x)*cos(2*f(x)) + cos(x)*sin(2*f(x))*f(x).diff(x),
'sol': [Eq(f(x), pi - acos(C1/cos(x)**2)/2), Eq(f(x), acos(C1/cos(x)**2)/2)],
},
'separable_20': {
'eq': (1 - x)*f(x).diff(x) - x*(f(x) + 1),
'sol': [Eq(f(x), (C1*exp(-x) - x + 1)/(x - 1))],
},
'separable_21': {
'eq': f(x)*diff(f(x), x) + x - 3*x*f(x)**2,
'sol': [Eq(f(x), -sqrt(3)*sqrt(C1*exp(3*x**2) + 1)/3),
Eq(f(x), sqrt(3)*sqrt(C1*exp(3*x**2) + 1)/3)],
},
'separable_22': {
'eq': f(x).diff(x) - exp(x + f(x)),
'sol': [Eq(f(x), log(-1/(C1 + exp(x))))],
'XFAIL': ['lie_group'] #It shows 'NoneType' object is not subscriptable for lie_group.
},
}
}
def __new__(cls, name, n, m):
n, m = _sympify(n), _sympify(m)
if isinstance(name, string_types):
name = Symbol(name)
obj = Basic.__new__(cls, name, n, m)
return obj
def lfsr_connection_polynomial(s):
"""
This function computes the lsfr connection polynomial.
INPUT:
``s``: a sequence of elements of even length, with entries in a finite field
OUTPUT:
``C(x)``: the connection polynomial of a minimal LFSR yielding ``s``.
This implements the algorithm in section 3 of J. L. Massey's article [M]_.
References
==========
.. [M] James L. Massey, "Shift-Register Synthesis and BCH Decoding."
IEEE Trans. on Information Theory, vol. 15(1), pp. 122-127, Jan 1969.
Examples
========
>>> from sympy.crypto.crypto import lfsr_sequence, lfsr_connection_polynomial
>>> from sympy.polys.domains import FF
>>> F = FF(2)
>>> fill = [F(1), F(1), F(0), F(1)]
>>> key = [F(1), F(0), F(0), F(1)]
>>> s = lfsr_sequence(key, fill, 20)
>>> lfsr_connection_polynomial(s)
x**4 + x + 1
>>> fill = [F(1), F(0), F(0), F(1)]
>>> key = [F(1), F(1), F(0), F(1)]
>>> s = lfsr_sequence(key, fill, 20)
>>> lfsr_connection_polynomial(s)
x**3 + 1
>>> fill = [F(1), F(0), F(1)]
>>> key = [F(1), F(1), F(0)]
>>> s = lfsr_sequence(key, fill, 20)
>>> lfsr_connection_polynomial(s)
x**3 + x**2 + 1
>>> fill = [F(1), F(0), F(1)]
>>> key = [F(1), F(0), F(1)]
>>> s = lfsr_sequence(key, fill, 20)
>>> lfsr_connection_polynomial(s)
x**3 + x + 1
"""
# Initialization:
p = s[0].mod
F = FF(p)
x = Symbol("x")
C = 1 * x**0
B = 1 * x**0
m = 1
b = 1 * x**0
L = 0
N = 0
while N < len(s):
if L > 0:
dC = Poly(C).degree()
r = min(L + 1, dC + 1)
coeffsC = [C.subs(x, 0)
] + [C.coeff(x**i) for i in range(1, dC + 1)]
d = (s[N].to_int() +
sum([coeffsC[i] * s[N - i].to_int()
for i in range(1, r)])) % p
if L == 0:
d = s[N].to_int() * x**0
if d == 0:
m += 1
N += 1
if d > 0:
if 2 * L > N:
C = (C - d * ((b**(p - 2)) % p) * x**m * B).expand()
m += 1
N += 1
else:
T = C
C = (C - d * ((b**(p - 2)) % p) * x**m * B).expand()
L = N + 1 - L
m = 1
b = d
B = T
N += 1
dC = Poly(C).degree()
coeffsC = [C.subs(x, 0)] + [C.coeff(x**i) for i in range(1, dC + 1)]
return sum([
coeffsC[i] % p * x**i for i in range(dC + 1) if coeffsC[i] is not None
])