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 ])