Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/sympy/benchmarks/bench_discrete_log.py

@@ -0,0 +1,83 @@
+import sys
+from time import time
+from sympy.ntheory.residue_ntheory import (discrete_log,
+        _discrete_log_trial_mul, _discrete_log_shanks_steps,
+        _discrete_log_pollard_rho, _discrete_log_pohlig_hellman)
+
+
+# Cyclic group (Z/pZ)* with p prime, order p - 1 and generator g
+data_set_1 = [
+        # p, p - 1, g
+        [191, 190, 19],
+        [46639, 46638, 6],
+        [14789363, 14789362, 2],
+        [4254225211, 4254225210, 2],
+        [432751500361, 432751500360, 7],
+        [158505390797053, 158505390797052, 2],
+        [6575202655312007, 6575202655312006, 5],
+        [8430573471995353769, 8430573471995353768, 3],
+        [3938471339744997827267, 3938471339744997827266, 2],
+        [875260951364705563393093, 875260951364705563393092, 5],
+    ]
+
+
+# Cyclic sub-groups of (Z/nZ)* with prime order p and generator g
+# (n, p are primes and n = 2 * p + 1)
+data_set_2 = [
+        # n, p, g
+        [227, 113, 3],
+        [2447, 1223, 2],
+        [24527, 12263, 2],
+        [245639, 122819, 2],
+        [2456747, 1228373, 3],
+        [24567899, 12283949, 3],
+        [245679023, 122839511, 2],
+        [2456791307, 1228395653, 3],
+        [24567913439, 12283956719, 2],
+        [245679135407, 122839567703, 2],
+        [2456791354763, 1228395677381, 3],
+        [24567913550903, 12283956775451, 2],
+        [245679135509519, 122839567754759, 2],
+    ]
+
+
+# Cyclic sub-groups of (Z/nZ)* with smooth order o and generator g
+data_set_3 = [
+        # n, o, g
+        [2**118, 2**116, 3],
+    ]
+
+
+def bench_discrete_log(data_set, algo=None):
+    if algo is None:
+        f = discrete_log
+    elif algo == 'trial':
+        f = _discrete_log_trial_mul
+    elif algo == 'shanks':
+        f = _discrete_log_shanks_steps
+    elif algo == 'rho':
+        f = _discrete_log_pollard_rho
+    elif algo == 'ph':
+        f = _discrete_log_pohlig_hellman
+    else:
+        raise ValueError("Argument 'algo' should be one"
+                " of ('trial', 'shanks', 'rho' or 'ph')")
+
+    for i, data in enumerate(data_set):
+        for j, (n, p, g) in enumerate(data):
+            t = time()
+            l = f(n, pow(g, p - 1, n), g, p)
+            t = time() - t
+            print('[%02d-%03d] %15.10f' % (i, j, t))
+            assert l == p - 1
+
+
+if __name__ == '__main__':
+    algo = sys.argv[1] \
+            if len(sys.argv) > 1 else None
+    data_set = [
+            data_set_1,
+            data_set_2,
+            data_set_3,
+        ]
+    bench_discrete_log(data_set, algo)

env-llmeval/lib/python3.10/site-packages/sympy/benchmarks/bench_meijerint.py

@@ -0,0 +1,261 @@
+# conceal the implicit import from the code quality tester
+from sympy.core.numbers import (oo, pi)
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.special.bessel import besseli
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import integrate
+from sympy.integrals.transforms import (mellin_transform,
+    inverse_fourier_transform, inverse_mellin_transform,
+    laplace_transform, inverse_laplace_transform, fourier_transform)
+
+LT = laplace_transform
+FT = fourier_transform
+MT = mellin_transform
+IFT = inverse_fourier_transform
+ILT = inverse_laplace_transform
+IMT = inverse_mellin_transform
+
+from sympy.abc import x, y
+nu, beta, rho = symbols('nu beta rho')
+
+apos, bpos, cpos, dpos, posk, p = symbols('a b c d k p', positive=True)
+k = Symbol('k', real=True)
+negk = Symbol('k', negative=True)
+
+mu1, mu2 = symbols('mu1 mu2', real=True, nonzero=True, finite=True)
+sigma1, sigma2 = symbols('sigma1 sigma2', real=True, nonzero=True,
+                         finite=True, positive=True)
+rate = Symbol('lambda', positive=True)
+
+
+def normal(x, mu, sigma):
+    return 1/sqrt(2*pi*sigma**2)*exp(-(x - mu)**2/2/sigma**2)
+
+
+def exponential(x, rate):
+    return rate*exp(-rate*x)
+alpha, beta = symbols('alpha beta', positive=True)
+betadist = x**(alpha - 1)*(1 + x)**(-alpha - beta)*gamma(alpha + beta) \
+    /gamma(alpha)/gamma(beta)
+kint = Symbol('k', integer=True, positive=True)
+chi = 2**(1 - kint/2)*x**(kint - 1)*exp(-x**2/2)/gamma(kint/2)
+chisquared = 2**(-k/2)/gamma(k/2)*x**(k/2 - 1)*exp(-x/2)
+dagum = apos*p/x*(x/bpos)**(apos*p)/(1 + x**apos/bpos**apos)**(p + 1)
+d1, d2 = symbols('d1 d2', positive=True)
+f = sqrt(((d1*x)**d1 * d2**d2)/(d1*x + d2)**(d1 + d2))/x \
+    /gamma(d1/2)/gamma(d2/2)*gamma((d1 + d2)/2)
+nupos, sigmapos = symbols('nu sigma', positive=True)
+rice = x/sigmapos**2*exp(-(x**2 + nupos**2)/2/sigmapos**2)*besseli(0, x*
+                         nupos/sigmapos**2)
+mu = Symbol('mu', real=True)
+laplace = exp(-abs(x - mu)/bpos)/2/bpos
+
+u = Symbol('u', polar=True)
+tpos = Symbol('t', positive=True)
+
+
+def E(expr):
+    integrate(expr*exponential(x, rate)*normal(y, mu1, sigma1),
+                     (x, 0, oo), (y, -oo, oo), meijerg=True)
+    integrate(expr*exponential(x, rate)*normal(y, mu1, sigma1),
+                     (y, -oo, oo), (x, 0, oo), meijerg=True)
+
+bench = [
+    'MT(x**nu*Heaviside(x - 1), x, s)',
+    'MT(x**nu*Heaviside(1 - x), x, s)',
+    'MT((1-x)**(beta - 1)*Heaviside(1-x), x, s)',
+    'MT((x-1)**(beta - 1)*Heaviside(x-1), x, s)',
+    'MT((1+x)**(-rho), x, s)',
+    'MT(abs(1-x)**(-rho), x, s)',
+    'MT((1-x)**(beta-1)*Heaviside(1-x) + a*(x-1)**(beta-1)*Heaviside(x-1), x, s)',
+    'MT((x**a-b**a)/(x-b), x, s)',
+    'MT((x**a-bpos**a)/(x-bpos), x, s)',
+    'MT(exp(-x), x, s)',
+    'MT(exp(-1/x), x, s)',
+    'MT(log(x)**4*Heaviside(1-x), x, s)',
+    'MT(log(x)**3*Heaviside(x-1), x, s)',
+    'MT(log(x + 1), x, s)',
+    'MT(log(1/x + 1), x, s)',
+    'MT(log(abs(1 - x)), x, s)',
+    'MT(log(abs(1 - 1/x)), x, s)',
+    'MT(log(x)/(x+1), x, s)',
+    'MT(log(x)**2/(x+1), x, s)',
+    'MT(log(x)/(x+1)**2, x, s)',
+    'MT(erf(sqrt(x)), x, s)',
+
+    'MT(besselj(a, 2*sqrt(x)), x, s)',
+    'MT(sin(sqrt(x))*besselj(a, sqrt(x)), x, s)',
+    'MT(cos(sqrt(x))*besselj(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))**2, x, s)',
+    'MT(besselj(a, sqrt(x))*besselj(-a, sqrt(x)), x, s)',
+    'MT(besselj(a - 1, sqrt(x))*besselj(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))*besselj(b, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))**2 + besselj(-a, sqrt(x))**2, x, s)',
+    'MT(bessely(a, 2*sqrt(x)), x, s)',
+    'MT(sin(sqrt(x))*bessely(a, sqrt(x)), x, s)',
+    'MT(cos(sqrt(x))*bessely(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))*bessely(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))*bessely(b, sqrt(x)), x, s)',
+    'MT(bessely(a, sqrt(x))**2, x, s)',
+
+    'MT(besselk(a, 2*sqrt(x)), x, s)',
+    'MT(besselj(a, 2*sqrt(2*sqrt(x)))*besselk(a, 2*sqrt(2*sqrt(x))), x, s)',
+    'MT(besseli(a, sqrt(x))*besselk(a, sqrt(x)), x, s)',
+    'MT(besseli(b, sqrt(x))*besselk(a, sqrt(x)), x, s)',
+    'MT(exp(-x/2)*besselk(a, x/2), x, s)',
+
+    # later: ILT, IMT
+
+    'LT((t-apos)**bpos*exp(-cpos*(t-apos))*Heaviside(t-apos), t, s)',
+    'LT(t**apos, t, s)',
+    'LT(Heaviside(t), t, s)',
+    'LT(Heaviside(t - apos), t, s)',
+    'LT(1 - exp(-apos*t), t, s)',
+    'LT((exp(2*t)-1)*exp(-bpos - t)*Heaviside(t)/2, t, s, noconds=True)',
+    'LT(exp(t), t, s)',
+    'LT(exp(2*t), t, s)',
+    'LT(exp(apos*t), t, s)',
+    'LT(log(t/apos), t, s)',
+    'LT(erf(t), t, s)',
+    'LT(sin(apos*t), t, s)',
+    'LT(cos(apos*t), t, s)',
+    'LT(exp(-apos*t)*sin(bpos*t), t, s)',
+    'LT(exp(-apos*t)*cos(bpos*t), t, s)',
+    'LT(besselj(0, t), t, s, noconds=True)',
+    'LT(besselj(1, t), t, s, noconds=True)',
+
+    'FT(Heaviside(1 - abs(2*apos*x)), x, k)',
+    'FT(Heaviside(1-abs(apos*x))*(1-abs(apos*x)), x, k)',
+    'FT(exp(-apos*x)*Heaviside(x), x, k)',
+    'IFT(1/(apos + 2*pi*I*x), x, posk, noconds=False)',
+    'IFT(1/(apos + 2*pi*I*x), x, -posk, noconds=False)',
+    'IFT(1/(apos + 2*pi*I*x), x, negk)',
+    'FT(x*exp(-apos*x)*Heaviside(x), x, k)',
+    'FT(exp(-apos*x)*sin(bpos*x)*Heaviside(x), x, k)',
+    'FT(exp(-apos*x**2), x, k)',
+    'IFT(sqrt(pi/apos)*exp(-(pi*k)**2/apos), k, x)',
+    'FT(exp(-apos*abs(x)), x, k)',
+
+    'integrate(normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(x*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(x**2*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(x**3*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(x*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(y*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(x*y*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate((x+y+1)*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate((x+y-1)*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '                   (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(x**2*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '                (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(y**2*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(exponential(x, rate), (x, 0, oo), meijerg=True)',
+    'integrate(x*exponential(x, rate), (x, 0, oo), meijerg=True)',
+    'integrate(x**2*exponential(x, rate), (x, 0, oo), meijerg=True)',
+    'E(1)',
+    'E(x*y)',
+    'E(x*y**2)',
+    'E((x+y+1)**2)',
+    'E(x+y+1)',
+    'E((x+y-1)**2)',
+    'integrate(betadist, (x, 0, oo), meijerg=True)',
+    'integrate(x*betadist, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*betadist, (x, 0, oo), meijerg=True)',
+    'integrate(chi, (x, 0, oo), meijerg=True)',
+    'integrate(x*chi, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*chi, (x, 0, oo), meijerg=True)',
+    'integrate(chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(x*chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(((x-k)/sqrt(2*k))**3*chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(dagum, (x, 0, oo), meijerg=True)',
+    'integrate(x*dagum, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*dagum, (x, 0, oo), meijerg=True)',
+    'integrate(f, (x, 0, oo), meijerg=True)',
+    'integrate(x*f, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*f, (x, 0, oo), meijerg=True)',
+    'integrate(rice, (x, 0, oo), meijerg=True)',
+    'integrate(laplace, (x, -oo, oo), meijerg=True)',
+    'integrate(x*laplace, (x, -oo, oo), meijerg=True)',
+    'integrate(x**2*laplace, (x, -oo, oo), meijerg=True)',
+    'integrate(log(x) * x**(k-1) * exp(-x) / gamma(k), (x, 0, oo))',
+
+    'integrate(sin(z*x)*(x**2-1)**(-(y+S(1)/2)), (x, 1, oo), meijerg=True)',
+    'integrate(besselj(0,x)*besselj(1,x)*exp(-x**2), (x, 0, oo), meijerg=True)',
+    'integrate(besselj(0,x)*besselj(1,x)*besselk(0,x), (x, 0, oo), meijerg=True)',
+    'integrate(besselj(0,x)*besselj(1,x)*exp(-x**2), (x, 0, oo), meijerg=True)',
+    'integrate(besselj(a,x)*besselj(b,x)/x, (x,0,oo), meijerg=True)',
+
+    'hyperexpand(meijerg((-s - a/2 + 1, -s + a/2 + 1), (-a/2 - S(1)/2, -s + a/2 + S(3)/2), (a/2, -a/2), (-a/2 - S(1)/2, -s + a/2 + S(3)/2), 1))',
+    "gammasimp(S('2**(2*s)*(-pi*gamma(-a + 1)*gamma(a + 1)*gamma(-a - s + 1)*gamma(-a + s - 1/2)*gamma(a - s + 3/2)*gamma(a + s + 1)/(a*(a + s)) - gamma(-a - 1/2)*gamma(-a + 1)*gamma(a + 1)*gamma(a + 3/2)*gamma(-s + 3/2)*gamma(s - 1/2)*gamma(-a + s + 1)*gamma(a - s + 1)/(a*(-a + s)))*gamma(-2*s + 1)*gamma(s + 1)/(pi*s*gamma(-a - 1/2)*gamma(a + 3/2)*gamma(-s + 1)*gamma(-s + 3/2)*gamma(s - 1/2)*gamma(-a - s + 1)*gamma(-a + s - 1/2)*gamma(a - s + 1)*gamma(a - s + 3/2))'))",
+
+    'mellin_transform(E1(x), x, s)',
+    'inverse_mellin_transform(gamma(s)/s, s, x, (0, oo))',
+    'mellin_transform(expint(a, x), x, s)',
+    'mellin_transform(Si(x), x, s)',
+    'inverse_mellin_transform(-2**s*sqrt(pi)*gamma((s + 1)/2)/(2*s*gamma(-s/2 + 1)), s, x, (-1, 0))',
+    'mellin_transform(Ci(sqrt(x)), x, s)',
+    'inverse_mellin_transform(-4**s*sqrt(pi)*gamma(s)/(2*s*gamma(-s + S(1)/2)),s, u, (0, 1))',
+    'laplace_transform(Ci(x), x, s)',
+    'laplace_transform(expint(a, x), x, s)',
+    'laplace_transform(expint(1, x), x, s)',
+    'laplace_transform(expint(2, x), x, s)',
+    'inverse_laplace_transform(-log(1 + s**2)/2/s, s, u)',
+    'inverse_laplace_transform(log(s + 1)/s, s, x)',
+    'inverse_laplace_transform((s - log(s + 1))/s**2, s, x)',
+    'laplace_transform(Chi(x), x, s)',
+    'laplace_transform(Shi(x), x, s)',
+
+    'integrate(exp(-z*x)/x, (x, 1, oo), meijerg=True, conds="none")',
+    'integrate(exp(-z*x)/x**2, (x, 1, oo), meijerg=True, conds="none")',
+    'integrate(exp(-z*x)/x**3, (x, 1, oo), meijerg=True,conds="none")',
+    'integrate(-cos(x)/x, (x, tpos, oo), meijerg=True)',
+    'integrate(-sin(x)/x, (x, tpos, oo), meijerg=True)',
+    'integrate(sin(x)/x, (x, 0, z), meijerg=True)',
+    'integrate(sinh(x)/x, (x, 0, z), meijerg=True)',
+    'integrate(exp(-x)/x, x, meijerg=True)',
+    'integrate(exp(-x)/x**2, x, meijerg=True)',
+    'integrate(cos(u)/u, u, meijerg=True)',
+    'integrate(cosh(u)/u, u, meijerg=True)',
+    'integrate(expint(1, x), x, meijerg=True)',
+    'integrate(expint(2, x), x, meijerg=True)',
+    'integrate(Si(x), x, meijerg=True)',
+    'integrate(Ci(u), u, meijerg=True)',
+    'integrate(Shi(x), x, meijerg=True)',
+    'integrate(Chi(u), u, meijerg=True)',
+    'integrate(Si(x)*exp(-x), (x, 0, oo), meijerg=True)',
+    'integrate(expint(1, x)*sin(x), (x, 0, oo), meijerg=True)'
+]
+
+from time import time
+from sympy.core.cache import clear_cache
+import sys
+
+timings = []
+
+if __name__ == '__main__':
+    for n, string in enumerate(bench):
+        clear_cache()
+        _t = time()
+        exec(string)
+        _t = time() - _t
+        timings += [(_t, string)]
+        sys.stdout.write('.')
+        sys.stdout.flush()
+        if n % (len(bench) // 10) == 0:
+            sys.stdout.write('%s' % (10*n // len(bench)))
+    print()
+
+    timings.sort(key=lambda x: -x[0])
+
+    for ti, string in timings:
+        print('%.2fs %s' % (ti, string))

env-llmeval/lib/python3.10/site-packages/sympy/benchmarks/bench_symbench.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+from sympy.core.random import random
+from sympy.core.numbers import (I, Integer, pi)
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.polys.polytools import factor
+from sympy.simplify.simplify import simplify
+from sympy.abc import x, y, z
+from timeit import default_timer as clock
+
+
+def bench_R1():
+    "real(f(f(f(f(f(f(f(f(f(f(i/2)))))))))))"
+    def f(z):
+        return sqrt(Integer(1)/3)*z**2 + I/3
+    f(f(f(f(f(f(f(f(f(f(I/2)))))))))).as_real_imag()[0]
+
+
+def bench_R2():
+    "Hermite polynomial hermite(15, y)"
+    def hermite(n, y):
+        if n == 1:
+            return 2*y
+        if n == 0:
+            return 1
+        return (2*y*hermite(n - 1, y) - 2*(n - 1)*hermite(n - 2, y)).expand()
+
+    hermite(15, y)
+
+
+def bench_R3():
+    "a = [bool(f==f) for _ in range(10)]"
+    f = x + y + z
+    [bool(f == f) for _ in range(10)]
+
+
+def bench_R4():
+    # we don't have Tuples
+    pass
+
+
+def bench_R5():
+    "blowup(L, 8); L=uniq(L)"
+    def blowup(L, n):
+        for i in range(n):
+            L.append( (L[i] + L[i + 1]) * L[i + 2] )
+
+    def uniq(x):
+        v = set(x)
+        return v
+    L = [x, y, z]
+    blowup(L, 8)
+    L = uniq(L)
+
+
+def bench_R6():
+    "sum(simplify((x+sin(i))/x+(x-sin(i))/x) for i in range(100))"
+    sum(simplify((x + sin(i))/x + (x - sin(i))/x) for i in range(100))
+
+
+def bench_R7():
+    "[f.subs(x, random()) for _ in range(10**4)]"
+    f = x**24 + 34*x**12 + 45*x**3 + 9*x**18 + 34*x**10 + 32*x**21
+    [f.subs(x, random()) for _ in range(10**4)]
+
+
+def bench_R8():
+    "right(x^2,0,5,10^4)"
+    def right(f, a, b, n):
+        a = sympify(a)
+        b = sympify(b)
+        n = sympify(n)
+        x = f.atoms(Symbol).pop()
+        Deltax = (b - a)/n
+        c = a
+        est = 0
+        for i in range(n):
+            c += Deltax
+            est += f.subs(x, c)
+        return est*Deltax
+
+    right(x**2, 0, 5, 10**4)
+
+
+def _bench_R9():
+    "factor(x^20 - pi^5*y^20)"
+    factor(x**20 - pi**5*y**20)
+
+
+def bench_R10():
+    "v = [-pi,-pi+1/10..,pi]"
+    def srange(min, max, step):
+        v = [min]
+        while (max - v[-1]).evalf() > 0:
+            v.append(v[-1] + step)
+        return v[:-1]
+    srange(-pi, pi, sympify(1)/10)
+
+
+def bench_R11():
+    "a = [random() + random()*I for w in [0..1000]]"
+    [random() + random()*I for w in range(1000)]
+
+
+def bench_S1():
+    "e=(x+y+z+1)**7;f=e*(e+1);f.expand()"
+    e = (x + y + z + 1)**7
+    f = e*(e + 1)
+    f.expand()
+
+
+if __name__ == '__main__':
+    benchmarks = [
+        bench_R1,
+        bench_R2,
+        bench_R3,
+        bench_R5,
+        bench_R6,
+        bench_R7,
+        bench_R8,
+        #_bench_R9,
+        bench_R10,
+        bench_R11,
+        #bench_S1,
+    ]
+
+    report = []
+    for b in benchmarks:
+        t = clock()
+        b()
+        t = clock() - t
+        print("%s%65s: %f" % (b.__name__, b.__doc__, t))

env-llmeval/lib/python3.10/site-packages/sympy/interactive/__init__.py

@@ -0,0 +1,8 @@
+"""Helper module for setting up interactive SymPy sessions. """
+
+from .printing import init_printing
+from .session import init_session
+from .traversal import interactive_traversal
+
+
+__all__ = ['init_printing', 'init_session', 'interactive_traversal']

env-llmeval/lib/python3.10/site-packages/sympy/interactive/printing.py

@@ -0,0 +1,562 @@
+"""Tools for setting up printing in interactive sessions. """
+
+from sympy.external.importtools import version_tuple
+from io import BytesIO
+
+from sympy.printing.latex import latex as default_latex
+from sympy.printing.preview import preview
+from sympy.utilities.misc import debug
+from sympy.printing.defaults import Printable
+
+
+def _init_python_printing(stringify_func, **settings):
+    """Setup printing in Python interactive session. """
+    import sys
+    import builtins
+
+    def _displayhook(arg):
+        """Python's pretty-printer display hook.
+
+           This function was adapted from:
+
+            https://www.python.org/dev/peps/pep-0217/
+
+        """
+        if arg is not None:
+            builtins._ = None
+            print(stringify_func(arg, **settings))
+            builtins._ = arg
+
+    sys.displayhook = _displayhook
+
+
+def _init_ipython_printing(ip, stringify_func, use_latex, euler, forecolor,
+                           backcolor, fontsize, latex_mode, print_builtin,
+                           latex_printer, scale, **settings):
+    """Setup printing in IPython interactive session. """
+    try:
+        from IPython.lib.latextools import latex_to_png
+    except ImportError:
+        pass
+
+    # Guess best font color if none was given based on the ip.colors string.
+    # From the IPython documentation:
+    #   It has four case-insensitive values: 'nocolor', 'neutral', 'linux',
+    #   'lightbg'. The default is neutral, which should be legible on either
+    #   dark or light terminal backgrounds. linux is optimised for dark
+    #   backgrounds and lightbg for light ones.
+    if forecolor is None:
+        color = ip.colors.lower()
+        if color == 'lightbg':
+            forecolor = 'Black'
+        elif color == 'linux':
+            forecolor = 'White'
+        else:
+            # No idea, go with gray.
+            forecolor = 'Gray'
+        debug("init_printing: Automatic foreground color:", forecolor)
+
+    if use_latex == "svg":
+        extra_preamble = "\n\\special{color %s}" % forecolor
+    else:
+        extra_preamble = ""
+
+    imagesize = 'tight'
+    offset = "0cm,0cm"
+    resolution = round(150*scale)
+    dvi = r"-T %s -D %d -bg %s -fg %s -O %s" % (
+        imagesize, resolution, backcolor, forecolor, offset)
+    dvioptions = dvi.split()
+
+    svg_scale = 150/72*scale
+    dvioptions_svg = ["--no-fonts", "--scale={}".format(svg_scale)]
+
+    debug("init_printing: DVIOPTIONS:", dvioptions)
+    debug("init_printing: DVIOPTIONS_SVG:", dvioptions_svg)
+
+    latex = latex_printer or default_latex
+
+    def _print_plain(arg, p, cycle):
+        """caller for pretty, for use in IPython 0.11"""
+        if _can_print(arg):
+            p.text(stringify_func(arg))
+        else:
+            p.text(IPython.lib.pretty.pretty(arg))
+
+    def _preview_wrapper(o):
+        exprbuffer = BytesIO()
+        try:
+            preview(o, output='png', viewer='BytesIO', euler=euler,
+                    outputbuffer=exprbuffer, extra_preamble=extra_preamble,
+                    dvioptions=dvioptions, fontsize=fontsize)
+        except Exception as e:
+            # IPython swallows exceptions
+            debug("png printing:", "_preview_wrapper exception raised:",
+                  repr(e))
+            raise
+        return exprbuffer.getvalue()
+
+    def _svg_wrapper(o):
+        exprbuffer = BytesIO()
+        try:
+            preview(o, output='svg', viewer='BytesIO', euler=euler,
+                    outputbuffer=exprbuffer, extra_preamble=extra_preamble,
+                    dvioptions=dvioptions_svg, fontsize=fontsize)
+        except Exception as e:
+            # IPython swallows exceptions
+            debug("svg printing:", "_preview_wrapper exception raised:",
+                  repr(e))
+            raise
+        return exprbuffer.getvalue().decode('utf-8')
+
+    def _matplotlib_wrapper(o):
+        # mathtext can't render some LaTeX commands. For example, it can't
+        # render any LaTeX environments such as array or matrix. So here we
+        # ensure that if mathtext fails to render, we return None.
+        try:
+            try:
+                return latex_to_png(o, color=forecolor, scale=scale)
+            except TypeError: #  Old IPython version without color and scale
+                return latex_to_png(o)
+        except ValueError as e:
+            debug('matplotlib exception caught:', repr(e))
+            return None
+
+
+    # Hook methods for builtin SymPy printers
+    printing_hooks = ('_latex', '_sympystr', '_pretty', '_sympyrepr')
+
+
+    def _can_print(o):
+        """Return True if type o can be printed with one of the SymPy printers.
+
+        If o is a container type, this is True if and only if every element of
+        o can be printed in this way.
+        """
+
+        try:
+            # If you're adding another type, make sure you add it to printable_types
+            # later in this file as well
+
+            builtin_types = (list, tuple, set, frozenset)
+            if isinstance(o, builtin_types):
+                # If the object is a custom subclass with a custom str or
+                # repr, use that instead.
+                if (type(o).__str__ not in (i.__str__ for i in builtin_types) or
+                    type(o).__repr__ not in (i.__repr__ for i in builtin_types)):
+                    return False
+                return all(_can_print(i) for i in o)
+            elif isinstance(o, dict):
+                return all(_can_print(i) and _can_print(o[i]) for i in o)
+            elif isinstance(o, bool):
+                return False
+            elif isinstance(o, Printable):
+                # types known to SymPy
+                return True
+            elif any(hasattr(o, hook) for hook in printing_hooks):
+                # types which add support themselves
+                return True
+            elif isinstance(o, (float, int)) and print_builtin:
+                return True
+            return False
+        except RuntimeError:
+            return False
+            # This is in case maximum recursion depth is reached.
+            # Since RecursionError is for versions of Python 3.5+
+            # so this is to guard against RecursionError for older versions.
+
+    def _print_latex_png(o):
+        """
+        A function that returns a png rendered by an external latex
+        distribution, falling back to matplotlib rendering
+        """
+        if _can_print(o):
+            s = latex(o, mode=latex_mode, **settings)
+            if latex_mode == 'plain':
+                s = '$\\displaystyle %s$' % s
+            try:
+                return _preview_wrapper(s)
+            except RuntimeError as e:
+                debug('preview failed with:', repr(e),
+                      ' Falling back to matplotlib backend')
+                if latex_mode != 'inline':
+                    s = latex(o, mode='inline', **settings)
+                return _matplotlib_wrapper(s)
+
+    def _print_latex_svg(o):
+        """
+        A function that returns a svg rendered by an external latex
+        distribution, no fallback available.
+        """
+        if _can_print(o):
+            s = latex(o, mode=latex_mode, **settings)
+            if latex_mode == 'plain':
+                s = '$\\displaystyle %s$' % s
+            try:
+                return _svg_wrapper(s)
+            except RuntimeError as e:
+                debug('preview failed with:', repr(e),
+                      ' No fallback available.')
+
+    def _print_latex_matplotlib(o):
+        """
+        A function that returns a png rendered by mathtext
+        """
+        if _can_print(o):
+            s = latex(o, mode='inline', **settings)
+            return _matplotlib_wrapper(s)
+
+    def _print_latex_text(o):
+        """
+        A function to generate the latex representation of SymPy expressions.
+        """
+        if _can_print(o):
+            s = latex(o, mode=latex_mode, **settings)
+            if latex_mode == 'plain':
+                return '$\\displaystyle %s$' % s
+            return s
+
+    def _result_display(self, arg):
+        """IPython's pretty-printer display hook, for use in IPython 0.10
+
+           This function was adapted from:
+
+            ipython/IPython/hooks.py:155
+
+        """
+        if self.rc.pprint:
+            out = stringify_func(arg)
+
+            if '\n' in out:
+                print()
+
+            print(out)
+        else:
+            print(repr(arg))
+
+    import IPython
+    if version_tuple(IPython.__version__) >= version_tuple('0.11'):
+
+        # Printable is our own type, so we handle it with methods instead of
+        # the approach required by builtin types. This allows downstream
+        # packages to override the methods in their own subclasses of Printable,
+        # which avoids the effects of gh-16002.
+        printable_types = [float, tuple, list, set, frozenset, dict, int]
+
+        plaintext_formatter = ip.display_formatter.formatters['text/plain']
+
+        # Exception to the rule above: IPython has better dispatching rules
+        # for plaintext printing (xref ipython/ipython#8938), and we can't
+        # use `_repr_pretty_` without hitting a recursion error in _print_plain.
+        for cls in printable_types + [Printable]:
+            plaintext_formatter.for_type(cls, _print_plain)
+
+        svg_formatter = ip.display_formatter.formatters['image/svg+xml']
+        if use_latex in ('svg', ):
+            debug("init_printing: using svg formatter")
+            for cls in printable_types:
+                svg_formatter.for_type(cls, _print_latex_svg)
+            Printable._repr_svg_ = _print_latex_svg
+        else:
+            debug("init_printing: not using any svg formatter")
+            for cls in printable_types:
+                # Better way to set this, but currently does not work in IPython
+                #png_formatter.for_type(cls, None)
+                if cls in svg_formatter.type_printers:
+                    svg_formatter.type_printers.pop(cls)
+            Printable._repr_svg_ = Printable._repr_disabled
+
+        png_formatter = ip.display_formatter.formatters['image/png']
+        if use_latex in (True, 'png'):
+            debug("init_printing: using png formatter")
+            for cls in printable_types:
+                png_formatter.for_type(cls, _print_latex_png)
+            Printable._repr_png_ = _print_latex_png
+        elif use_latex == 'matplotlib':
+            debug("init_printing: using matplotlib formatter")
+            for cls in printable_types:
+                png_formatter.for_type(cls, _print_latex_matplotlib)
+            Printable._repr_png_ = _print_latex_matplotlib
+        else:
+            debug("init_printing: not using any png formatter")
+            for cls in printable_types:
+                # Better way to set this, but currently does not work in IPython
+                #png_formatter.for_type(cls, None)
+                if cls in png_formatter.type_printers:
+                    png_formatter.type_printers.pop(cls)
+            Printable._repr_png_ = Printable._repr_disabled
+
+        latex_formatter = ip.display_formatter.formatters['text/latex']
+        if use_latex in (True, 'mathjax'):
+            debug("init_printing: using mathjax formatter")
+            for cls in printable_types:
+                latex_formatter.for_type(cls, _print_latex_text)
+            Printable._repr_latex_ = _print_latex_text
+        else:
+            debug("init_printing: not using text/latex formatter")
+            for cls in printable_types:
+                # Better way to set this, but currently does not work in IPython
+                #latex_formatter.for_type(cls, None)
+                if cls in latex_formatter.type_printers:
+                    latex_formatter.type_printers.pop(cls)
+            Printable._repr_latex_ = Printable._repr_disabled
+
+    else:
+        ip.set_hook('result_display', _result_display)
+
+def _is_ipython(shell):
+    """Is a shell instance an IPython shell?"""
+    # shortcut, so we don't import IPython if we don't have to
+    from sys import modules
+    if 'IPython' not in modules:
+        return False
+    try:
+        from IPython.core.interactiveshell import InteractiveShell
+    except ImportError:
+        # IPython < 0.11
+        try:
+            from IPython.iplib import InteractiveShell
+        except ImportError:
+            # Reaching this points means IPython has changed in a backward-incompatible way
+            # that we don't know about. Warn?
+            return False
+    return isinstance(shell, InteractiveShell)
+
+# Used by the doctester to override the default for no_global
+NO_GLOBAL = False
+
+def init_printing(pretty_print=True, order=None, use_unicode=None,
+                  use_latex=None, wrap_line=None, num_columns=None,
+                  no_global=False, ip=None, euler=False, forecolor=None,
+                  backcolor='Transparent', fontsize='10pt',
+                  latex_mode='plain', print_builtin=True,
+                  str_printer=None, pretty_printer=None,
+                  latex_printer=None, scale=1.0, **settings):
+    r"""
+    Initializes pretty-printer depending on the environment.
+
+    Parameters
+    ==========
+
+    pretty_print : bool, default=True
+        If ``True``, use :func:`~.pretty_print` to stringify or the provided pretty
+        printer; if ``False``, use :func:`~.sstrrepr` to stringify or the provided string
+        printer.
+    order : string or None, default='lex'
+        There are a few different settings for this parameter:
+        ``'lex'`` (default), which is lexographic order;
+        ``'grlex'``, which is graded lexographic order;
+        ``'grevlex'``, which is reversed graded lexographic order;
+        ``'old'``, which is used for compatibility reasons and for long expressions;
+        ``None``, which sets it to lex.
+    use_unicode : bool or None, default=None
+        If ``True``, use unicode characters;
+        if ``False``, do not use unicode characters;
+        if ``None``, make a guess based on the environment.
+    use_latex : string, bool, or None, default=None
+        If ``True``, use default LaTeX rendering in GUI interfaces (png and
+        mathjax);
+        if ``False``, do not use LaTeX rendering;
+        if ``None``, make a guess based on the environment;
+        if ``'png'``, enable LaTeX rendering with an external LaTeX compiler,
+        falling back to matplotlib if external compilation fails;
+        if ``'matplotlib'``, enable LaTeX rendering with matplotlib;
+        if ``'mathjax'``, enable LaTeX text generation, for example MathJax
+        rendering in IPython notebook or text rendering in LaTeX documents;
+        if ``'svg'``, enable LaTeX rendering with an external latex compiler,
+        no fallback
+    wrap_line : bool
+        If True, lines will wrap at the end; if False, they will not wrap
+        but continue as one line. This is only relevant if ``pretty_print`` is
+        True.
+    num_columns : int or None, default=None
+        If ``int``, number of columns before wrapping is set to num_columns; if
+        ``None``, number of columns before wrapping is set to terminal width.
+        This is only relevant if ``pretty_print`` is ``True``.
+    no_global : bool, default=False
+        If ``True``, the settings become system wide;
+        if ``False``, use just for this console/session.
+    ip : An interactive console
+        This can either be an instance of IPython,
+        or a class that derives from code.InteractiveConsole.
+    euler : bool, optional, default=False
+        Loads the euler package in the LaTeX preamble for handwritten style
+        fonts (https://www.ctan.org/pkg/euler).
+    forecolor : string or None, optional, default=None
+        DVI setting for foreground color. ``None`` means that either ``'Black'``,
+        ``'White'``, or ``'Gray'`` will be selected based on a guess of the IPython
+        terminal color setting. See notes.
+    backcolor : string, optional, default='Transparent'
+        DVI setting for background color. See notes.
+    fontsize : string or int, optional, default='10pt'
+        A font size to pass to the LaTeX documentclass function in the
+        preamble. Note that the options are limited by the documentclass.
+        Consider using scale instead.
+    latex_mode : string, optional, default='plain'
+        The mode used in the LaTeX printer. Can be one of:
+        ``{'inline'|'plain'|'equation'|'equation*'}``.
+    print_builtin : boolean, optional, default=True
+        If ``True`` then floats and integers will be printed. If ``False`` the
+        printer will only print SymPy types.
+    str_printer : function, optional, default=None
+        A custom string printer function. This should mimic
+        :func:`~.sstrrepr()`.
+    pretty_printer : function, optional, default=None
+        A custom pretty printer. This should mimic :func:`~.pretty()`.
+    latex_printer : function, optional, default=None
+        A custom LaTeX printer. This should mimic :func:`~.latex()`.
+    scale : float, optional, default=1.0
+        Scale the LaTeX output when using the ``'png'`` or ``'svg'`` backends.
+        Useful for high dpi screens.
+    settings :
+        Any additional settings for the ``latex`` and ``pretty`` commands can
+        be used to fine-tune the output.
+
+    Examples
+    ========
+
+    >>> from sympy.interactive import init_printing
+    >>> from sympy import Symbol, sqrt
+    >>> from sympy.abc import x, y
+    >>> sqrt(5)
+    sqrt(5)
+    >>> init_printing(pretty_print=True) # doctest: +SKIP
+    >>> sqrt(5) # doctest: +SKIP
+      ___
+    \/ 5
+    >>> theta = Symbol('theta') # doctest: +SKIP
+    >>> init_printing(use_unicode=True) # doctest: +SKIP
+    >>> theta # doctest: +SKIP
+    \u03b8
+    >>> init_printing(use_unicode=False) # doctest: +SKIP
+    >>> theta # doctest: +SKIP
+    theta
+    >>> init_printing(order='lex') # doctest: +SKIP
+    >>> str(y + x + y**2 + x**2) # doctest: +SKIP
+    x**2 + x + y**2 + y
+    >>> init_printing(order='grlex') # doctest: +SKIP
+    >>> str(y + x + y**2 + x**2) # doctest: +SKIP
+    x**2 + x + y**2 + y
+    >>> init_printing(order='grevlex') # doctest: +SKIP
+    >>> str(y * x**2 + x * y**2) # doctest: +SKIP
+    x**2*y + x*y**2
+    >>> init_printing(order='old') # doctest: +SKIP
+    >>> str(x**2 + y**2 + x + y) # doctest: +SKIP
+    x**2 + x + y**2 + y
+    >>> init_printing(num_columns=10) # doctest: +SKIP
+    >>> x**2 + x + y**2 + y # doctest: +SKIP
+    x + y +
+    x**2 + y**2
+
+    Notes
+    =====
+
+    The foreground and background colors can be selected when using ``'png'`` or
+    ``'svg'`` LaTeX rendering. Note that before the ``init_printing`` command is
+    executed, the LaTeX rendering is handled by the IPython console and not SymPy.
+
+    The colors can be selected among the 68 standard colors known to ``dvips``,
+    for a list see [1]_. In addition, the background color can be
+    set to  ``'Transparent'`` (which is the default value).
+
+    When using the ``'Auto'`` foreground color, the guess is based on the
+    ``colors`` variable in the IPython console, see [2]_. Hence, if
+    that variable is set correctly in your IPython console, there is a high
+    chance that the output will be readable, although manual settings may be
+    needed.
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikibooks.org/wiki/LaTeX/Colors#The_68_standard_colors_known_to_dvips
+
+    .. [2] https://ipython.readthedocs.io/en/stable/config/details.html#terminal-colors
+
+    See Also
+    ========
+
+    sympy.printing.latex
+    sympy.printing.pretty
+
+    """
+    import sys
+    from sympy.printing.printer import Printer
+
+    if pretty_print:
+        if pretty_printer is not None:
+            stringify_func = pretty_printer
+        else:
+            from sympy.printing import pretty as stringify_func
+    else:
+        if str_printer is not None:
+            stringify_func = str_printer
+        else:
+            from sympy.printing import sstrrepr as stringify_func
+
+    # Even if ip is not passed, double check that not in IPython shell
+    in_ipython = False
+    if ip is None:
+        try:
+            ip = get_ipython()
+        except NameError:
+            pass
+        else:
+            in_ipython = (ip is not None)
+
+    if ip and not in_ipython:
+        in_ipython = _is_ipython(ip)
+
+    if in_ipython and pretty_print:
+        try:
+            import IPython
+            # IPython 1.0 deprecates the frontend module, so we import directly
+            # from the terminal module to prevent a deprecation message from being
+            # shown.
+            if version_tuple(IPython.__version__) >= version_tuple('1.0'):
+                from IPython.terminal.interactiveshell import TerminalInteractiveShell
+            else:
+                from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
+            from code import InteractiveConsole
+        except ImportError:
+            pass
+        else:
+            # This will be True if we are in the qtconsole or notebook
+            if not isinstance(ip, (InteractiveConsole, TerminalInteractiveShell)) \
+                    and 'ipython-console' not in ''.join(sys.argv):
+                if use_unicode is None:
+                    debug("init_printing: Setting use_unicode to True")
+                    use_unicode = True
+                if use_latex is None:
+                    debug("init_printing: Setting use_latex to True")
+                    use_latex = True
+
+    if not NO_GLOBAL and not no_global:
+        Printer.set_global_settings(order=order, use_unicode=use_unicode,
+                                    wrap_line=wrap_line, num_columns=num_columns)
+    else:
+        _stringify_func = stringify_func
+
+        if pretty_print:
+            stringify_func = lambda expr, **settings: \
+                             _stringify_func(expr, order=order,
+                                             use_unicode=use_unicode,
+                                             wrap_line=wrap_line,
+                                             num_columns=num_columns,
+                                             **settings)
+        else:
+            stringify_func = \
+                lambda expr, **settings: _stringify_func(
+                    expr, order=order, **settings)
+
+    if in_ipython:
+        mode_in_settings = settings.pop("mode", None)
+        if mode_in_settings:
+            debug("init_printing: Mode is not able to be set due to internals"
+                  "of IPython printing")
+        _init_ipython_printing(ip, stringify_func, use_latex, euler,
+                               forecolor, backcolor, fontsize, latex_mode,
+                               print_builtin, latex_printer, scale,
+                               **settings)
+    else:
+        _init_python_printing(stringify_func, **settings)

env-llmeval/lib/python3.10/site-packages/sympy/interactive/traversal.py

@@ -0,0 +1,95 @@
+from sympy.core.basic import Basic
+from sympy.printing import pprint
+
+import random
+
+def interactive_traversal(expr):
+    """Traverse a tree asking a user which branch to choose. """
+
+    RED, BRED = '\033[0;31m', '\033[1;31m'
+    GREEN, BGREEN = '\033[0;32m', '\033[1;32m'
+    YELLOW, BYELLOW = '\033[0;33m', '\033[1;33m'  # noqa
+    BLUE, BBLUE = '\033[0;34m', '\033[1;34m'      # noqa
+    MAGENTA, BMAGENTA = '\033[0;35m', '\033[1;35m'# noqa
+    CYAN, BCYAN = '\033[0;36m', '\033[1;36m'      # noqa
+    END = '\033[0m'
+
+    def cprint(*args):
+        print("".join(map(str, args)) + END)
+
+    def _interactive_traversal(expr, stage):
+        if stage > 0:
+            print()
+
+        cprint("Current expression (stage ", BYELLOW, stage, END, "):")
+        print(BCYAN)
+        pprint(expr)
+        print(END)
+
+        if isinstance(expr, Basic):
+            if expr.is_Add:
+                args = expr.as_ordered_terms()
+            elif expr.is_Mul:
+                args = expr.as_ordered_factors()
+            else:
+                args = expr.args
+        elif hasattr(expr, "__iter__"):
+            args = list(expr)
+        else:
+            return expr
+
+        n_args = len(args)
+
+        if not n_args:
+            return expr
+
+        for i, arg in enumerate(args):
+            cprint(GREEN, "[", BGREEN, i, GREEN, "] ", BLUE, type(arg), END)
+            pprint(arg)
+            print()
+
+        if n_args == 1:
+            choices = '0'
+        else:
+            choices = '0-%d' % (n_args - 1)
+
+        try:
+            choice = input("Your choice [%s,f,l,r,d,?]: " % choices)
+        except EOFError:
+            result = expr
+            print()
+        else:
+            if choice == '?':
+                cprint(RED, "%s - select subexpression with the given index" %
+                       choices)
+                cprint(RED, "f - select the first subexpression")
+                cprint(RED, "l - select the last subexpression")
+                cprint(RED, "r - select a random subexpression")
+                cprint(RED, "d - done\n")
+
+                result = _interactive_traversal(expr, stage)
+            elif choice in ('d', ''):
+                result = expr
+            elif choice == 'f':
+                result = _interactive_traversal(args[0], stage + 1)
+            elif choice == 'l':
+                result = _interactive_traversal(args[-1], stage + 1)
+            elif choice == 'r':
+                result = _interactive_traversal(random.choice(args), stage + 1)
+            else:
+                try:
+                    choice = int(choice)
+                except ValueError:
+                    cprint(BRED,
+                           "Choice must be a number in %s range\n" % choices)
+                    result = _interactive_traversal(expr, stage)
+                else:
+                    if choice < 0 or choice >= n_args:
+                        cprint(BRED, "Choice must be in %s range\n" % choices)
+                        result = _interactive_traversal(expr, stage)
+                    else:
+                        result = _interactive_traversal(args[choice], stage + 1)
+
+        return result
+
+    return _interactive_traversal(expr, 0)

env-llmeval/lib/python3.10/site-packages/sympy/solvers/benchmarks/bench_solvers.py

@@ -0,0 +1,12 @@
+from sympy.core.symbol import Symbol
+from sympy.matrices.dense import (eye, zeros)
+from sympy.solvers.solvers import solve_linear_system
+
+N = 8
+M = zeros(N, N + 1)
+M[:, :N] = eye(N)
+S = [Symbol('A%i' % i) for i in range(N)]
+
+
+def timeit_linsolve_trivial():
+    solve_linear_system(M, *S)

env-llmeval/lib/python3.10/site-packages/sympy/solvers/tests/test_constantsimp.py

@@ -0,0 +1,179 @@
+"""
+If the arbitrary constant class from issue 4435 is ever implemented, this
+should serve as a set of test cases.
+"""
+
+from sympy.core.function import Function
+from sympy.core.numbers import I
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (cosh, sinh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, cos, sin)
+from sympy.integrals.integrals import Integral
+from sympy.solvers.ode.ode import constantsimp, constant_renumber
+from sympy.testing.pytest import XFAIL
+
+
+x = Symbol('x')
+y = Symbol('y')
+z = Symbol('z')
+u2 = Symbol('u2')
+_a = Symbol('_a')
+C1 = Symbol('C1')
+C2 = Symbol('C2')
+C3 = Symbol('C3')
+f = Function('f')
+
+
+def test_constant_mul():
+    # We want C1 (Constant) below to absorb the y's, but not the x's
+    assert constant_renumber(constantsimp(y*C1, [C1])) == C1*y
+    assert constant_renumber(constantsimp(C1*y, [C1])) == C1*y
+    assert constant_renumber(constantsimp(x*C1, [C1])) == x*C1
+    assert constant_renumber(constantsimp(C1*x, [C1])) == x*C1
+    assert constant_renumber(constantsimp(2*C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1*2, [C1])) == C1
+    assert constant_renumber(constantsimp(y*C1*x, [C1, y])) == C1*x
+    assert constant_renumber(constantsimp(x*y*C1, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp(y*x*C1, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp(C1*x*y, [C1, y])) == C1*x
+    assert constant_renumber(constantsimp(x*C1*y, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp(C1*y*(y + 1), [C1])) == C1*y*(y+1)
+    assert constant_renumber(constantsimp(y*C1*(y + 1), [C1])) == C1*y*(y+1)
+    assert constant_renumber(constantsimp(x*(y*C1), [C1])) == x*y*C1
+    assert constant_renumber(constantsimp(x*(C1*y), [C1])) == x*y*C1
+    assert constant_renumber(constantsimp(C1*(x*y), [C1, y])) == C1*x
+    assert constant_renumber(constantsimp((x*y)*C1, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp((y*x)*C1, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp(y*(y + 1)*C1, [C1, y])) == C1
+    assert constant_renumber(constantsimp((C1*x)*y, [C1, y])) == C1*x
+    assert constant_renumber(constantsimp(y*(x*C1), [C1, y])) == x*C1
+    assert constant_renumber(constantsimp((x*C1)*y, [C1, y])) == x*C1
+    assert constant_renumber(constantsimp(C1*x*y*x*y*2, [C1, y])) == C1*x**2
+    assert constant_renumber(constantsimp(C1*x*y*z, [C1, y, z])) == C1*x
+    assert constant_renumber(constantsimp(C1*x*y**2*sin(z), [C1, y, z])) == C1*x
+    assert constant_renumber(constantsimp(C1*C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1*C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C2*C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C1*C1*C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C1*x*2**x, [C1])) == C1*x*2**x
+
+def test_constant_add():
+    assert constant_renumber(constantsimp(C1 + C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1 + 2, [C1])) == C1
+    assert constant_renumber(constantsimp(2 + C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1 + y, [C1, y])) == C1
+    assert constant_renumber(constantsimp(C1 + x, [C1])) == C1 + x
+    assert constant_renumber(constantsimp(C1 + C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1 + C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C2 + C1, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C1 + C2 + C1, [C1, C2])) == C1
+
+
+def test_constant_power_as_base():
+    assert constant_renumber(constantsimp(C1**C1, [C1])) == C1
+    assert constant_renumber(constantsimp(Pow(C1, C1), [C1])) == C1
+    assert constant_renumber(constantsimp(C1**C1, [C1])) == C1
+    assert constant_renumber(constantsimp(C1**C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C2**C1, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C2**C2, [C1, C2])) == C1
+    assert constant_renumber(constantsimp(C1**y, [C1, y])) == C1
+    assert constant_renumber(constantsimp(C1**x, [C1])) == C1**x
+    assert constant_renumber(constantsimp(C1**2, [C1])) == C1
+    assert constant_renumber(
+        constantsimp(C1**(x*y), [C1])) == C1**(x*y)
+
+
+def test_constant_power_as_exp():
+    assert constant_renumber(constantsimp(x**C1, [C1])) == x**C1
+    assert constant_renumber(constantsimp(y**C1, [C1, y])) == C1
+    assert constant_renumber(constantsimp(x**y**C1, [C1, y])) == x**C1
+    assert constant_renumber(
+        constantsimp((x**y)**C1, [C1])) == (x**y)**C1
+    assert constant_renumber(
+        constantsimp(x**(y**C1), [C1, y])) == x**C1
+    assert constant_renumber(constantsimp(x**C1**y, [C1, y])) == x**C1
+    assert constant_renumber(
+        constantsimp(x**(C1**y), [C1, y])) == x**C1
+    assert constant_renumber(
+        constantsimp((x**C1)**y, [C1])) == (x**C1)**y
+    assert constant_renumber(constantsimp(2**C1, [C1])) == C1
+    assert constant_renumber(constantsimp(S(2)**C1, [C1])) == C1
+    assert constant_renumber(constantsimp(exp(C1), [C1])) == C1
+    assert constant_renumber(
+        constantsimp(exp(C1 + x), [C1])) == C1*exp(x)
+    assert constant_renumber(constantsimp(Pow(2, C1), [C1])) == C1
+
+
+def test_constant_function():
+    assert constant_renumber(constantsimp(sin(C1), [C1])) == C1
+    assert constant_renumber(constantsimp(f(C1), [C1])) == C1
+    assert constant_renumber(constantsimp(f(C1, C1), [C1])) == C1
+    assert constant_renumber(constantsimp(f(C1, C2), [C1, C2])) == C1
+    assert constant_renumber(constantsimp(f(C2, C1), [C1, C2])) == C1
+    assert constant_renumber(constantsimp(f(C2, C2), [C1, C2])) == C1
+    assert constant_renumber(
+        constantsimp(f(C1, x), [C1])) == f(C1, x)
+    assert constant_renumber(constantsimp(f(C1, y), [C1, y])) == C1
+    assert constant_renumber(constantsimp(f(y, C1), [C1, y])) == C1
+    assert constant_renumber(constantsimp(f(C1, y, C2), [C1, C2, y])) == C1
+
+
+def test_constant_function_multiple():
+    # The rules to not renumber in this case would be too complicated, and
+    # dsolve is not likely to ever encounter anything remotely like this.
+    assert constant_renumber(
+        constantsimp(f(C1, C1, x), [C1])) == f(C1, C1, x)
+
+
+def test_constant_multiple():
+    assert constant_renumber(constantsimp(C1*2 + 2, [C1])) == C1
+    assert constant_renumber(constantsimp(x*2/C1, [C1])) == C1*x
+    assert constant_renumber(constantsimp(C1**2*2 + 2, [C1])) == C1
+    assert constant_renumber(
+        constantsimp(sin(2*C1) + x + sqrt(2), [C1])) == C1 + x
+    assert constant_renumber(constantsimp(2*C1 + C2, [C1, C2])) == C1
+
+def test_constant_repeated():
+    assert C1 + C1*x == constant_renumber( C1 + C1*x)
+
+def test_ode_solutions():
+    # only a few examples here, the rest will be tested in the actual dsolve tests
+    assert constant_renumber(constantsimp(C1*exp(2*x) + exp(x)*(C2 + C3), [C1, C2, C3])) == \
+        constant_renumber(C1*exp(x) + C2*exp(2*x))
+    assert constant_renumber(
+        constantsimp(Eq(f(x), I*C1*sinh(x/3) + C2*cosh(x/3)), [C1, C2])
+        ) == constant_renumber(Eq(f(x), C1*sinh(x/3) + C2*cosh(x/3)))
+    assert constant_renumber(constantsimp(Eq(f(x), acos((-C1)/cos(x))), [C1])) == \
+        Eq(f(x), acos(C1/cos(x)))
+    assert constant_renumber(
+        constantsimp(Eq(log(f(x)/C1) + 2*exp(x/f(x)), 0), [C1])
+        ) == Eq(log(C1*f(x)) + 2*exp(x/f(x)), 0)
+    assert constant_renumber(constantsimp(Eq(log(x*sqrt(2)*sqrt(1/x)*sqrt(f(x))
+        /C1) + x**2/(2*f(x)**2), 0), [C1])) == \
+        Eq(log(C1*sqrt(x)*sqrt(f(x))) + x**2/(2*f(x)**2), 0)
+    assert constant_renumber(constantsimp(Eq(-exp(-f(x)/x)*sin(f(x)/x)/2 + log(x/C1) -
+        cos(f(x)/x)*exp(-f(x)/x)/2, 0), [C1])) == \
+        Eq(-exp(-f(x)/x)*sin(f(x)/x)/2 + log(C1*x) - cos(f(x)/x)*
+           exp(-f(x)/x)/2, 0)
+    assert constant_renumber(constantsimp(Eq(-Integral(-1/(sqrt(1 - u2**2)*u2),
+        (u2, _a, x/f(x))) + log(f(x)/C1), 0), [C1])) == \
+        Eq(-Integral(-1/(u2*sqrt(1 - u2**2)), (u2, _a, x/f(x))) +
+        log(C1*f(x)), 0)
+    assert [constantsimp(i, [C1]) for i in [Eq(f(x), sqrt(-C1*x + x**2)), Eq(f(x), -sqrt(-C1*x + x**2))]] == \
+        [Eq(f(x), sqrt(x*(C1 + x))), Eq(f(x), -sqrt(x*(C1 + x)))]
+
+
+@XFAIL
+def test_nonlocal_simplification():
+    assert constantsimp(C1 + C2+x*C2, [C1, C2]) == C1 + C2*x
+
+
+def test_constant_Eq():
+    # C1 on the rhs is well-tested, but the lhs is only tested here
+    assert constantsimp(Eq(C1, 3 + f(x)*x), [C1]) == Eq(x*f(x), C1)
+    assert constantsimp(Eq(C1, 3 * f(x)*x), [C1]) == Eq(f(x)*x, C1)

env-llmeval/lib/python3.10/site-packages/sympy/solvers/tests/test_decompogen.py

@@ -0,0 +1,59 @@
+from sympy.solvers.decompogen import decompogen, compogen
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt, Max
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.testing.pytest import XFAIL, raises
+
+x, y = symbols('x y')
+
+
+def test_decompogen():
+    assert decompogen(sin(cos(x)), x) == [sin(x), cos(x)]
+    assert decompogen(sin(x)**2 + sin(x) + 1, x) == [x**2 + x + 1, sin(x)]
+    assert decompogen(sqrt(6*x**2 - 5), x) == [sqrt(x), 6*x**2 - 5]
+    assert decompogen(sin(sqrt(cos(x**2 + 1))), x) == [sin(x), sqrt(x), cos(x), x**2 + 1]
+    assert decompogen(Abs(cos(x)**2 + 3*cos(x) - 4), x) == [Abs(x), x**2 + 3*x - 4, cos(x)]
+    assert decompogen(sin(x)**2 + sin(x) - sqrt(3)/2, x) == [x**2 + x - sqrt(3)/2, sin(x)]
+    assert decompogen(Abs(cos(y)**2 + 3*cos(x) - 4), x) == [Abs(x), 3*x + cos(y)**2 - 4, cos(x)]
+    assert decompogen(x, y) == [x]
+    assert decompogen(1, x) == [1]
+    assert decompogen(Max(3, x), x) == [Max(3, x)]
+    raises(TypeError, lambda: decompogen(x < 5, x))
+    u = 2*x + 3
+    assert decompogen(Max(sqrt(u),(u)**2), x) == [Max(sqrt(x), x**2), u]
+    assert decompogen(Max(u, u**2, y), x) == [Max(x, x**2, y), u]
+    assert decompogen(Max(sin(x), u), x) == [Max(2*x + 3, sin(x))]
+
+
+def test_decompogen_poly():
+    assert decompogen(x**4 + 2*x**2 + 1, x) == [x**2 + 2*x + 1, x**2]
+    assert decompogen(x**4 + 2*x**3 - x - 1, x) == [x**2 - x - 1, x**2 + x]
+
+
+@XFAIL
+def test_decompogen_fails():
+    A = lambda x: x**2 + 2*x + 3
+    B = lambda x: 4*x**2 + 5*x + 6
+    assert decompogen(A(x*exp(x)), x) == [x**2 + 2*x + 3, x*exp(x)]
+    assert decompogen(A(B(x)), x) == [x**2 + 2*x + 3, 4*x**2 + 5*x + 6]
+    assert decompogen(A(1/x + 1/x**2), x) == [x**2 + 2*x + 3, 1/x + 1/x**2]
+    assert decompogen(A(1/x + 2/(x + 1)), x) == [x**2 + 2*x + 3, 1/x + 2/(x + 1)]
+
+
+def test_compogen():
+    assert compogen([sin(x), cos(x)], x) == sin(cos(x))
+    assert compogen([x**2 + x + 1, sin(x)], x) == sin(x)**2 + sin(x) + 1
+    assert compogen([sqrt(x), 6*x**2 - 5], x) == sqrt(6*x**2 - 5)
+    assert compogen([sin(x), sqrt(x), cos(x), x**2 + 1], x) == sin(sqrt(
+                                                                cos(x**2 + 1)))
+    assert compogen([Abs(x), x**2 + 3*x - 4, cos(x)], x) == Abs(cos(x)**2 +
+                                                                3*cos(x) - 4)
+    assert compogen([x**2 + x - sqrt(3)/2, sin(x)], x) == (sin(x)**2 + sin(x) -
+                                                           sqrt(3)/2)
+    assert compogen([Abs(x), 3*x + cos(y)**2 - 4, cos(x)], x) == \
+        Abs(3*cos(x) + cos(y)**2 - 4)
+    assert compogen([x**2 + 2*x + 1, x**2], x) == x**4 + 2*x**2 + 1
+    # the result is in unsimplified form
+    assert compogen([x**2 - x - 1, x**2 + x], x) == -x**2 - x + (x**2 + x)**2 - 1

env-llmeval/lib/python3.10/site-packages/sympy/solvers/tests/test_pde.py

@@ -0,0 +1,239 @@
+from sympy.core.function import (Derivative as D, Function)
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.core import S
+from sympy.solvers.pde import (pde_separate, pde_separate_add, pde_separate_mul,
+    pdsolve, classify_pde, checkpdesol)
+from sympy.testing.pytest import raises
+
+
+a, b, c, x, y = symbols('a b c x y')
+
+def test_pde_separate_add():
+    x, y, z, t = symbols("x,y,z,t")
+    F, T, X, Y, Z, u = map(Function, 'FTXYZu')
+
+    eq = Eq(D(u(x, t), x), D(u(x, t), t)*exp(u(x, t)))
+    res = pde_separate_add(eq, u(x, t), [X(x), T(t)])
+    assert res == [D(X(x), x)*exp(-X(x)), D(T(t), t)*exp(T(t))]
+
+
+def test_pde_separate():
+    x, y, z, t = symbols("x,y,z,t")
+    F, T, X, Y, Z, u = map(Function, 'FTXYZu')
+
+    eq = Eq(D(u(x, t), x), D(u(x, t), t)*exp(u(x, t)))
+    raises(ValueError, lambda: pde_separate(eq, u(x, t), [X(x), T(t)], 'div'))
+
+
+def test_pde_separate_mul():
+    x, y, z, t = symbols("x,y,z,t")
+    c = Symbol("C", real=True)
+    Phi = Function('Phi')
+    F, R, T, X, Y, Z, u = map(Function, 'FRTXYZu')
+    r, theta, z = symbols('r,theta,z')
+
+    # Something simple :)
+    eq = Eq(D(F(x, y, z), x) + D(F(x, y, z), y) + D(F(x, y, z), z), 0)
+
+    # Duplicate arguments in functions
+    raises(
+        ValueError, lambda: pde_separate_mul(eq, F(x, y, z), [X(x), u(z, z)]))
+    # Wrong number of arguments
+    raises(ValueError, lambda: pde_separate_mul(eq, F(x, y, z), [X(x), Y(y)]))
+    # Wrong variables: [x, y] -> [x, z]
+    raises(
+        ValueError, lambda: pde_separate_mul(eq, F(x, y, z), [X(t), Y(x, y)]))
+
+    assert pde_separate_mul(eq, F(x, y, z), [Y(y), u(x, z)]) == \
+        [D(Y(y), y)/Y(y), -D(u(x, z), x)/u(x, z) - D(u(x, z), z)/u(x, z)]
+    assert pde_separate_mul(eq, F(x, y, z), [X(x), Y(y), Z(z)]) == \
+        [D(X(x), x)/X(x), -D(Z(z), z)/Z(z) - D(Y(y), y)/Y(y)]
+
+    # wave equation
+    wave = Eq(D(u(x, t), t, t), c**2*D(u(x, t), x, x))
+    res = pde_separate_mul(wave, u(x, t), [X(x), T(t)])
+    assert res == [D(X(x), x, x)/X(x), D(T(t), t, t)/(c**2*T(t))]
+
+    # Laplace equation in cylindrical coords
+    eq = Eq(1/r * D(Phi(r, theta, z), r) + D(Phi(r, theta, z), r, 2) +
+            1/r**2 * D(Phi(r, theta, z), theta, 2) + D(Phi(r, theta, z), z, 2), 0)
+    # Separate z
+    res = pde_separate_mul(eq, Phi(r, theta, z), [Z(z), u(theta, r)])
+    assert res == [D(Z(z), z, z)/Z(z),
+            -D(u(theta, r), r, r)/u(theta, r) -
+        D(u(theta, r), r)/(r*u(theta, r)) -
+        D(u(theta, r), theta, theta)/(r**2*u(theta, r))]
+    # Lets use the result to create a new equation...
+    eq = Eq(res[1], c)
+    # ...and separate theta...
+    res = pde_separate_mul(eq, u(theta, r), [T(theta), R(r)])
+    assert res == [D(T(theta), theta, theta)/T(theta),
+            -r*D(R(r), r)/R(r) - r**2*D(R(r), r, r)/R(r) - c*r**2]
+    # ...or r...
+    res = pde_separate_mul(eq, u(theta, r), [R(r), T(theta)])
+    assert res == [r*D(R(r), r)/R(r) + r**2*D(R(r), r, r)/R(r) + c*r**2,
+            -D(T(theta), theta, theta)/T(theta)]
+
+
+def test_issue_11726():
+    x, t = symbols("x t")
+    f  = symbols("f", cls=Function)
+    X, T = symbols("X T", cls=Function)
+
+    u = f(x, t)
+    eq = u.diff(x, 2) - u.diff(t, 2)
+    res = pde_separate(eq, u, [T(x), X(t)])
+    assert res == [D(T(x), x, x)/T(x),D(X(t), t, t)/X(t)]
+
+
+def test_pde_classify():
+    # When more number of hints are added, add tests for classifying here.
+    f = Function('f')
+    eq1 = a*f(x,y) + b*f(x,y).diff(x) + c*f(x,y).diff(y)
+    eq2 = 3*f(x,y) + 2*f(x,y).diff(x) + f(x,y).diff(y)
+    eq3 = a*f(x,y) + b*f(x,y).diff(x) + 2*f(x,y).diff(y)
+    eq4 = x*f(x,y) + f(x,y).diff(x) + 3*f(x,y).diff(y)
+    eq5 = x**2*f(x,y) + x*f(x,y).diff(x) + x*y*f(x,y).diff(y)
+    eq6 = y*x**2*f(x,y) + y*f(x,y).diff(x) + f(x,y).diff(y)
+    for eq in [eq1, eq2, eq3]:
+        assert classify_pde(eq) == ('1st_linear_constant_coeff_homogeneous',)
+    for eq in [eq4, eq5, eq6]:
+        assert classify_pde(eq) == ('1st_linear_variable_coeff',)
+
+
+def test_checkpdesol():
+    f, F = map(Function, ['f', 'F'])
+    eq1 = a*f(x,y) + b*f(x,y).diff(x) + c*f(x,y).diff(y)
+    eq2 = 3*f(x,y) + 2*f(x,y).diff(x) + f(x,y).diff(y)
+    eq3 = a*f(x,y) + b*f(x,y).diff(x) + 2*f(x,y).diff(y)
+    for eq in [eq1, eq2, eq3]:
+        assert checkpdesol(eq, pdsolve(eq))[0]
+    eq4 = x*f(x,y) + f(x,y).diff(x) + 3*f(x,y).diff(y)
+    eq5 = 2*f(x,y) + 1*f(x,y).diff(x) + 3*f(x,y).diff(y)
+    eq6 = f(x,y) + 1*f(x,y).diff(x) + 3*f(x,y).diff(y)
+    assert checkpdesol(eq4, [pdsolve(eq5), pdsolve(eq6)]) == [
+        (False, (x - 2)*F(3*x - y)*exp(-x/S(5) - 3*y/S(5))),
+         (False, (x - 1)*F(3*x - y)*exp(-x/S(10) - 3*y/S(10)))]
+    for eq in [eq4, eq5, eq6]:
+        assert checkpdesol(eq, pdsolve(eq))[0]
+    sol = pdsolve(eq4)
+    sol4 = Eq(sol.lhs - sol.rhs, 0)
+    raises(NotImplementedError, lambda:
+        checkpdesol(eq4, sol4, solve_for_func=False))
+
+
+def test_solvefun():
+    f, F, G, H = map(Function, ['f', 'F', 'G', 'H'])
+    eq1 = f(x,y) + f(x,y).diff(x) + f(x,y).diff(y)
+    assert pdsolve(eq1) == Eq(f(x, y), F(x - y)*exp(-x/2 - y/2))
+    assert pdsolve(eq1, solvefun=G) == Eq(f(x, y), G(x - y)*exp(-x/2 - y/2))
+    assert pdsolve(eq1, solvefun=H) == Eq(f(x, y), H(x - y)*exp(-x/2 - y/2))
+
+
+def test_pde_1st_linear_constant_coeff_homogeneous():
+    f, F = map(Function, ['f', 'F'])
+    u = f(x, y)
+    eq = 2*u + u.diff(x) + u.diff(y)
+    assert classify_pde(eq) == ('1st_linear_constant_coeff_homogeneous',)
+    sol = pdsolve(eq)
+    assert sol == Eq(u, F(x - y)*exp(-x - y))
+    assert checkpdesol(eq, sol)[0]
+
+    eq = 4 + (3*u.diff(x)/u) + (2*u.diff(y)/u)
+    assert classify_pde(eq) == ('1st_linear_constant_coeff_homogeneous',)
+    sol = pdsolve(eq)
+    assert sol == Eq(u, F(2*x - 3*y)*exp(-S(12)*x/13 - S(8)*y/13))
+    assert checkpdesol(eq, sol)[0]
+
+    eq = u + (6*u.diff(x)) + (7*u.diff(y))
+    assert classify_pde(eq) == ('1st_linear_constant_coeff_homogeneous',)
+    sol = pdsolve(eq)
+    assert sol == Eq(u, F(7*x - 6*y)*exp(-6*x/S(85) - 7*y/S(85)))
+    assert checkpdesol(eq, sol)[0]
+
+    eq = a*u + b*u.diff(x) + c*u.diff(y)
+    sol = pdsolve(eq)
+    assert checkpdesol(eq, sol)[0]
+
+
+def test_pde_1st_linear_constant_coeff():
+    f, F = map(Function, ['f', 'F'])
+    u = f(x,y)
+    eq = -2*u.diff(x) + 4*u.diff(y) + 5*u - exp(x + 3*y)
+    sol = pdsolve(eq)
+    assert sol == Eq(f(x,y),
+    (F(4*x + 2*y)*exp(x/2) + exp(x + 4*y)/15)*exp(-y))
+    assert classify_pde(eq) == ('1st_linear_constant_coeff',
+    '1st_linear_constant_coeff_Integral')
+    assert checkpdesol(eq, sol)[0]
+
+    eq = (u.diff(x)/u) + (u.diff(y)/u) + 1 - (exp(x + y)/u)
+    sol = pdsolve(eq)
+    assert sol == Eq(f(x, y), F(x - y)*exp(-x/2 - y/2) + exp(x + y)/3)
+    assert classify_pde(eq) == ('1st_linear_constant_coeff',
+    '1st_linear_constant_coeff_Integral')
+    assert checkpdesol(eq, sol)[0]
+
+    eq = 2*u + -u.diff(x) + 3*u.diff(y) + sin(x)
+    sol = pdsolve(eq)
+    assert sol == Eq(f(x, y),
+         F(3*x + y)*exp(x/5 - 3*y/5) - 2*sin(x)/5 - cos(x)/5)
+    assert classify_pde(eq) == ('1st_linear_constant_coeff',
+    '1st_linear_constant_coeff_Integral')
+    assert checkpdesol(eq, sol)[0]
+
+    eq = u + u.diff(x) + u.diff(y) + x*y
+    sol = pdsolve(eq)
+    assert sol.expand() == Eq(f(x, y),
+        x + y + (x - y)**2/4 - (x + y)**2/4 + F(x - y)*exp(-x/2 - y/2) - 2).expand()
+    assert classify_pde(eq) == ('1st_linear_constant_coeff',
+    '1st_linear_constant_coeff_Integral')
+    assert checkpdesol(eq, sol)[0]
+    eq = u + u.diff(x) + u.diff(y) + log(x)
+    assert classify_pde(eq) == ('1st_linear_constant_coeff',
+    '1st_linear_constant_coeff_Integral')
+
+
+def test_pdsolve_all():
+    f, F = map(Function, ['f', 'F'])
+    u = f(x,y)
+    eq = u + u.diff(x) + u.diff(y) + x**2*y
+    sol = pdsolve(eq, hint = 'all')
+    keys = ['1st_linear_constant_coeff',
+        '1st_linear_constant_coeff_Integral', 'default', 'order']
+    assert sorted(sol.keys()) == keys
+    assert sol['order'] == 1
+    assert sol['default'] == '1st_linear_constant_coeff'
+    assert sol['1st_linear_constant_coeff'].expand() == Eq(f(x, y),
+        -x**2*y + x**2 + 2*x*y - 4*x - 2*y + F(x - y)*exp(-x/2 - y/2) + 6).expand()
+
+
+def test_pdsolve_variable_coeff():
+    f, F = map(Function, ['f', 'F'])
+    u = f(x, y)
+    eq = x*(u.diff(x)) - y*(u.diff(y)) + y**2*u - y**2
+    sol = pdsolve(eq, hint="1st_linear_variable_coeff")
+    assert sol == Eq(u, F(x*y)*exp(y**2/2) + 1)
+    assert checkpdesol(eq, sol)[0]
+
+    eq = x**2*u + x*u.diff(x) + x*y*u.diff(y)
+    sol = pdsolve(eq, hint='1st_linear_variable_coeff')
+    assert sol == Eq(u, F(y*exp(-x))*exp(-x**2/2))
+    assert checkpdesol(eq, sol)[0]
+
+    eq = y*x**2*u + y*u.diff(x) + u.diff(y)
+    sol = pdsolve(eq, hint='1st_linear_variable_coeff')
+    assert sol == Eq(u, F(-2*x + y**2)*exp(-x**3/3))
+    assert checkpdesol(eq, sol)[0]
+
+    eq = exp(x)**2*(u.diff(x)) + y
+    sol = pdsolve(eq, hint='1st_linear_variable_coeff')
+    assert sol == Eq(u, y*exp(-2*x)/2 + F(y))
+    assert checkpdesol(eq, sol)[0]
+
+    eq = exp(2*x)*(u.diff(y)) + y*u - u
+    sol = pdsolve(eq, hint='1st_linear_variable_coeff')
+    assert sol == Eq(u, F(x)*exp(-y*(y - 2)*exp(-2*x)/2))

env-llmeval/lib/python3.10/site-packages/sympy/solvers/tests/test_polysys.py

@@ -0,0 +1,178 @@
+"""Tests for solvers of systems of polynomial equations. """
+from sympy.core.numbers import (I, Integer, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.polys.domains.rationalfield import QQ
+from sympy.polys.polyerrors import UnsolvableFactorError
+from sympy.polys.polyoptions import Options
+from sympy.polys.polytools import Poly
+from sympy.solvers.solvers import solve
+from sympy.utilities.iterables import flatten
+from sympy.abc import x, y, z
+from sympy.polys import PolynomialError
+from sympy.solvers.polysys import (solve_poly_system,
+                                   solve_triangulated,
+                                   solve_biquadratic, SolveFailed,
+                                   solve_generic)
+from sympy.polys.polytools import parallel_poly_from_expr
+from sympy.testing.pytest import raises
+
+
+def test_solve_poly_system():
+    assert solve_poly_system([x - 1], x) == [(S.One,)]
+
+    assert solve_poly_system([y - x, y - x - 1], x, y) is None
+
+    assert solve_poly_system([y - x**2, y + x**2], x, y) == [(S.Zero, S.Zero)]
+
+    assert solve_poly_system([2*x - 3, y*Rational(3, 2) - 2*x, z - 5*y], x, y, z) == \
+        [(Rational(3, 2), Integer(2), Integer(10))]
+
+    assert solve_poly_system([x*y - 2*y, 2*y**2 - x**2], x, y) == \
+        [(0, 0), (2, -sqrt(2)), (2, sqrt(2))]
+
+    assert solve_poly_system([y - x**2, y + x**2 + 1], x, y) == \
+        [(-I*sqrt(S.Half), Rational(-1, 2)), (I*sqrt(S.Half), Rational(-1, 2))]
+
+    f_1 = x**2 + y + z - 1
+    f_2 = x + y**2 + z - 1
+    f_3 = x + y + z**2 - 1
+
+    a, b = sqrt(2) - 1, -sqrt(2) - 1
+
+    assert solve_poly_system([f_1, f_2, f_3], x, y, z) == \
+        [(0, 0, 1), (0, 1, 0), (1, 0, 0), (a, a, a), (b, b, b)]
+
+    solution = [(1, -1), (1, 1)]
+
+    assert solve_poly_system([Poly(x**2 - y**2), Poly(x - 1)]) == solution
+    assert solve_poly_system([x**2 - y**2, x - 1], x, y) == solution
+    assert solve_poly_system([x**2 - y**2, x - 1]) == solution
+
+    assert solve_poly_system(
+        [x + x*y - 3, y + x*y - 4], x, y) == [(-3, -2), (1, 2)]
+
+    raises(NotImplementedError, lambda: solve_poly_system([x**3 - y**3], x, y))
+    raises(NotImplementedError, lambda: solve_poly_system(
+        [z, -2*x*y**2 + x + y**2*z, y**2*(-z - 4) + 2]))
+    raises(PolynomialError, lambda: solve_poly_system([1/x], x))
+
+    raises(NotImplementedError, lambda: solve_poly_system(
+          [x-1,], (x, y)))
+    raises(NotImplementedError, lambda: solve_poly_system(
+          [y-1,], (x, y)))
+
+    # solve_poly_system should ideally construct solutions using
+    # CRootOf for the following four tests
+    assert solve_poly_system([x**5 - x + 1], [x], strict=False) == []
+    raises(UnsolvableFactorError, lambda: solve_poly_system(
+        [x**5 - x + 1], [x], strict=True))
+
+    assert solve_poly_system([(x - 1)*(x**5 - x + 1), y**2 - 1], [x, y],
+                             strict=False) == [(1, -1), (1, 1)]
+    raises(UnsolvableFactorError,
+           lambda: solve_poly_system([(x - 1)*(x**5 - x + 1), y**2-1],
+                                     [x, y], strict=True))
+
+
+def test_solve_generic():
+    NewOption = Options((x, y), {'domain': 'ZZ'})
+    assert solve_generic([x**2 - 2*y**2, y**2 - y + 1], NewOption) == \
+           [(-sqrt(-1 - sqrt(3)*I), Rational(1, 2) - sqrt(3)*I/2),
+            (sqrt(-1 - sqrt(3)*I), Rational(1, 2) - sqrt(3)*I/2),
+            (-sqrt(-1 + sqrt(3)*I), Rational(1, 2) + sqrt(3)*I/2),
+            (sqrt(-1 + sqrt(3)*I), Rational(1, 2) + sqrt(3)*I/2)]
+
+    # solve_generic should ideally construct solutions using
+    # CRootOf for the following two tests
+    assert solve_generic(
+        [2*x - y, (y - 1)*(y**5 - y + 1)], NewOption, strict=False) == \
+        [(Rational(1, 2), 1)]
+    raises(UnsolvableFactorError, lambda: solve_generic(
+        [2*x - y, (y - 1)*(y**5 - y + 1)], NewOption, strict=True))
+
+
+def test_solve_biquadratic():
+    x0, y0, x1, y1, r = symbols('x0 y0 x1 y1 r')
+
+    f_1 = (x - 1)**2 + (y - 1)**2 - r**2
+    f_2 = (x - 2)**2 + (y - 2)**2 - r**2
+    s = sqrt(2*r**2 - 1)
+    a = (3 - s)/2
+    b = (3 + s)/2
+    assert solve_poly_system([f_1, f_2], x, y) == [(a, b), (b, a)]
+
+    f_1 = (x - 1)**2 + (y - 2)**2 - r**2
+    f_2 = (x - 1)**2 + (y - 1)**2 - r**2
+
+    assert solve_poly_system([f_1, f_2], x, y) == \
+        [(1 - sqrt((2*r - 1)*(2*r + 1))/2, Rational(3, 2)),
+         (1 + sqrt((2*r - 1)*(2*r + 1))/2, Rational(3, 2))]
+
+    query = lambda expr: expr.is_Pow and expr.exp is S.Half
+
+    f_1 = (x - 1 )**2 + (y - 2)**2 - r**2
+    f_2 = (x - x1)**2 + (y - 1)**2 - r**2
+
+    result = solve_poly_system([f_1, f_2], x, y)
+
+    assert len(result) == 2 and all(len(r) == 2 for r in result)
+    assert all(r.count(query) == 1 for r in flatten(result))
+
+    f_1 = (x - x0)**2 + (y - y0)**2 - r**2
+    f_2 = (x - x1)**2 + (y - y1)**2 - r**2
+
+    result = solve_poly_system([f_1, f_2], x, y)
+
+    assert len(result) == 2 and all(len(r) == 2 for r in result)
+    assert all(len(r.find(query)) == 1 for r in flatten(result))
+
+    s1 = (x*y - y, x**2 - x)
+    assert solve(s1) == [{x: 1}, {x: 0, y: 0}]
+    s2 = (x*y - x, y**2 - y)
+    assert solve(s2) == [{y: 1}, {x: 0, y: 0}]
+    gens = (x, y)
+    for seq in (s1, s2):
+        (f, g), opt = parallel_poly_from_expr(seq, *gens)
+        raises(SolveFailed, lambda: solve_biquadratic(f, g, opt))
+    seq = (x**2 + y**2 - 2, y**2 - 1)
+    (f, g), opt = parallel_poly_from_expr(seq, *gens)
+    assert solve_biquadratic(f, g, opt) == [
+        (-1, -1), (-1, 1), (1, -1), (1, 1)]
+    ans = [(0, -1), (0, 1)]
+    seq = (x**2 + y**2 - 1, y**2 - 1)
+    (f, g), opt = parallel_poly_from_expr(seq, *gens)
+    assert solve_biquadratic(f, g, opt) == ans
+    seq = (x**2 + y**2 - 1, x**2 - x + y**2 - 1)
+    (f, g), opt = parallel_poly_from_expr(seq, *gens)
+    assert solve_biquadratic(f, g, opt) == ans
+
+
+def test_solve_triangulated():
+    f_1 = x**2 + y + z - 1
+    f_2 = x + y**2 + z - 1
+    f_3 = x + y + z**2 - 1
+
+    a, b = sqrt(2) - 1, -sqrt(2) - 1
+
+    assert solve_triangulated([f_1, f_2, f_3], x, y, z) == \
+        [(0, 0, 1), (0, 1, 0), (1, 0, 0)]
+
+    dom = QQ.algebraic_field(sqrt(2))
+
+    assert solve_triangulated([f_1, f_2, f_3], x, y, z, domain=dom) == \
+        [(0, 0, 1), (0, 1, 0), (1, 0, 0), (a, a, a), (b, b, b)]
+
+
+def test_solve_issue_3686():
+    roots = solve_poly_system([((x - 5)**2/250000 + (y - Rational(5, 10))**2/250000) - 1, x], x, y)
+    assert roots == [(0, S.Half - 15*sqrt(1111)), (0, S.Half + 15*sqrt(1111))]
+
+    roots = solve_poly_system([((x - 5)**2/250000 + (y - 5.0/10)**2/250000) - 1, x], x, y)
+    # TODO: does this really have to be so complicated?!
+    assert len(roots) == 2
+    assert roots[0][0] == 0
+    assert roots[0][1].epsilon_eq(-499.474999374969, 1e12)
+    assert roots[1][0] == 0
+    assert roots[1][1].epsilon_eq(500.474999374969, 1e12)

env-llmeval/lib/python3.10/site-packages/sympy/vector/deloperator.py

@@ -0,0 +1,121 @@
+from sympy.core import Basic
+from sympy.vector.operators import gradient, divergence, curl
+
+
+class Del(Basic):
+    """
+    Represents the vector differential operator, usually represented in
+    mathematical expressions as the 'nabla' symbol.
+    """
+
+    def __new__(cls):
+        obj = super().__new__(cls)
+        obj._name = "delop"
+        return obj
+
+    def gradient(self, scalar_field, doit=False):
+        """
+        Returns the gradient of the given scalar field, as a
+        Vector instance.
+
+        Parameters
+        ==========
+
+        scalar_field : SymPy expression
+            The scalar field to calculate the gradient of.
+
+        doit : bool
+            If True, the result is returned after calling .doit() on
+            each component. Else, the returned expression contains
+            Derivative instances
+
+        Examples
+        ========
+
+        >>> from sympy.vector import CoordSys3D, Del
+        >>> C = CoordSys3D('C')
+        >>> delop = Del()
+        >>> delop.gradient(9)
+        0
+        >>> delop(C.x*C.y*C.z).doit()
+        C.y*C.z*C.i + C.x*C.z*C.j + C.x*C.y*C.k
+
+        """
+
+        return gradient(scalar_field, doit=doit)
+
+    __call__ = gradient
+    __call__.__doc__ = gradient.__doc__
+
+    def dot(self, vect, doit=False):
+        """
+        Represents the dot product between this operator and a given
+        vector - equal to the divergence of the vector field.
+
+        Parameters
+        ==========
+
+        vect : Vector
+            The vector whose divergence is to be calculated.
+
+        doit : bool
+            If True, the result is returned after calling .doit() on
+            each component. Else, the returned expression contains
+            Derivative instances
+
+        Examples
+        ========
+
+        >>> from sympy.vector import CoordSys3D, Del
+        >>> delop = Del()
+        >>> C = CoordSys3D('C')
+        >>> delop.dot(C.x*C.i)
+        Derivative(C.x, C.x)
+        >>> v = C.x*C.y*C.z * (C.i + C.j + C.k)
+        >>> (delop & v).doit()
+        C.x*C.y + C.x*C.z + C.y*C.z
+
+        """
+        return divergence(vect, doit=doit)
+
+    __and__ = dot
+    __and__.__doc__ = dot.__doc__
+
+    def cross(self, vect, doit=False):
+        """
+        Represents the cross product between this operator and a given
+        vector - equal to the curl of the vector field.
+
+        Parameters
+        ==========
+
+        vect : Vector
+            The vector whose curl is to be calculated.
+
+        doit : bool
+            If True, the result is returned after calling .doit() on
+            each component. Else, the returned expression contains
+            Derivative instances
+
+        Examples
+        ========
+
+        >>> from sympy.vector import CoordSys3D, Del
+        >>> C = CoordSys3D('C')
+        >>> delop = Del()
+        >>> v = C.x*C.y*C.z * (C.i + C.j + C.k)
+        >>> delop.cross(v, doit = True)
+        (-C.x*C.y + C.x*C.z)*C.i + (C.x*C.y - C.y*C.z)*C.j +
+            (-C.x*C.z + C.y*C.z)*C.k
+        >>> (delop ^ C.i).doit()
+        0
+
+        """
+
+        return curl(vect, doit=doit)
+
+    __xor__ = cross
+    __xor__.__doc__ = cross.__doc__
+
+    def _sympystr(self, printer):
+        return self._name

env-llmeval/lib/python3.10/site-packages/sympy/vector/functions.py

@@ -0,0 +1,517 @@
+from sympy.vector.coordsysrect import CoordSys3D
+from sympy.vector.deloperator import Del
+from sympy.vector.scalar import BaseScalar
+from sympy.vector.vector import Vector, BaseVector
+from sympy.vector.operators import gradient, curl, divergence
+from sympy.core.function import diff
+from sympy.core.singleton import S
+from sympy.integrals.integrals import integrate
+from sympy.simplify.simplify import simplify
+from sympy.core import sympify
+from sympy.vector.dyadic import Dyadic
+
+
+def express(expr, system, system2=None, variables=False):
+    """
+    Global function for 'express' functionality.
+
+    Re-expresses a Vector, Dyadic or scalar(sympyfiable) in the given
+    coordinate system.
+
+    If 'variables' is True, then the coordinate variables (base scalars)
+    of other coordinate systems present in the vector/scalar field or
+    dyadic are also substituted in terms of the base scalars of the
+    given system.
+
+    Parameters
+    ==========
+
+    expr : Vector/Dyadic/scalar(sympyfiable)
+        The expression to re-express in CoordSys3D 'system'
+
+    system: CoordSys3D
+        The coordinate system the expr is to be expressed in
+
+    system2: CoordSys3D
+        The other coordinate system required for re-expression
+        (only for a Dyadic Expr)
+
+    variables : boolean
+        Specifies whether to substitute the coordinate variables present
+        in expr, in terms of those of parameter system
+
+    Examples
+    ========
+
+    >>> from sympy.vector import CoordSys3D
+    >>> from sympy import Symbol, cos, sin
+    >>> N = CoordSys3D('N')
+    >>> q = Symbol('q')
+    >>> B = N.orient_new_axis('B', q, N.k)
+    >>> from sympy.vector import express
+    >>> express(B.i, N)
+    (cos(q))*N.i + (sin(q))*N.j
+    >>> express(N.x, B, variables=True)
+    B.x*cos(q) - B.y*sin(q)
+    >>> d = N.i.outer(N.i)
+    >>> express(d, B, N) == (cos(q))*(B.i|N.i) + (-sin(q))*(B.j|N.i)
+    True
+
+    """
+
+    if expr in (0, Vector.zero):
+        return expr
+
+    if not isinstance(system, CoordSys3D):
+        raise TypeError("system should be a CoordSys3D \
+                        instance")
+
+    if isinstance(expr, Vector):
+        if system2 is not None:
+            raise ValueError("system2 should not be provided for \
+                                Vectors")
+        # Given expr is a Vector
+        if variables:
+            # If variables attribute is True, substitute
+            # the coordinate variables in the Vector
+            system_list = {x.system for x in expr.atoms(BaseScalar, BaseVector)} - {system}
+            subs_dict = {}
+            for f in system_list:
+                subs_dict.update(f.scalar_map(system))
+            expr = expr.subs(subs_dict)
+        # Re-express in this coordinate system
+        outvec = Vector.zero
+        parts = expr.separate()
+        for x in parts:
+            if x != system:
+                temp = system.rotation_matrix(x) * parts[x].to_matrix(x)
+                outvec += matrix_to_vector(temp, system)
+            else:
+                outvec += parts[x]
+        return outvec
+
+    elif isinstance(expr, Dyadic):
+        if system2 is None:
+            system2 = system
+        if not isinstance(system2, CoordSys3D):
+            raise TypeError("system2 should be a CoordSys3D \
+                            instance")
+        outdyad = Dyadic.zero
+        var = variables
+        for k, v in expr.components.items():
+            outdyad += (express(v, system, variables=var) *
+                        (express(k.args[0], system, variables=var) |
+                         express(k.args[1], system2, variables=var)))
+
+        return outdyad
+
+    else:
+        if system2 is not None:
+            raise ValueError("system2 should not be provided for \
+                                Vectors")
+        if variables:
+            # Given expr is a scalar field
+            system_set = set()
+            expr = sympify(expr)
+            # Substitute all the coordinate variables
+            for x in expr.atoms(BaseScalar):
+                if x.system != system:
+                    system_set.add(x.system)
+            subs_dict = {}
+            for f in system_set:
+                subs_dict.update(f.scalar_map(system))
+            return expr.subs(subs_dict)
+        return expr
+
+
+def directional_derivative(field, direction_vector):
+    """
+    Returns the directional derivative of a scalar or vector field computed
+    along a given vector in coordinate system which parameters are expressed.
+
+    Parameters
+    ==========
+
+    field : Vector or Scalar
+        The scalar or vector field to compute the directional derivative of
+
+    direction_vector : Vector
+        The vector to calculated directional derivative along them.
+
+
+    Examples
+    ========
+
+    >>> from sympy.vector import CoordSys3D, directional_derivative
+    >>> R = CoordSys3D('R')
+    >>> f1 = R.x*R.y*R.z
+    >>> v1 = 3*R.i + 4*R.j + R.k
+    >>> directional_derivative(f1, v1)
+    R.x*R.y + 4*R.x*R.z + 3*R.y*R.z
+    >>> f2 = 5*R.x**2*R.z
+    >>> directional_derivative(f2, v1)
+    5*R.x**2 + 30*R.x*R.z
+
+    """
+    from sympy.vector.operators import _get_coord_systems
+    coord_sys = _get_coord_systems(field)
+    if len(coord_sys) > 0:
+        # TODO: This gets a random coordinate system in case of multiple ones:
+        coord_sys = next(iter(coord_sys))
+        field = express(field, coord_sys, variables=True)
+        i, j, k = coord_sys.base_vectors()
+        x, y, z = coord_sys.base_scalars()
+        out = Vector.dot(direction_vector, i) * diff(field, x)
+        out += Vector.dot(direction_vector, j) * diff(field, y)
+        out += Vector.dot(direction_vector, k) * diff(field, z)
+        if out == 0 and isinstance(field, Vector):
+            out = Vector.zero
+        return out
+    elif isinstance(field, Vector):
+        return Vector.zero
+    else:
+        return S.Zero
+
+
+def laplacian(expr):
+    """
+    Return the laplacian of the given field computed in terms of
+    the base scalars of the given coordinate system.
+
+    Parameters
+    ==========
+
+    expr : SymPy Expr or Vector
+        expr denotes a scalar or vector field.
+
+    Examples
+    ========
+
+    >>> from sympy.vector import CoordSys3D, laplacian
+    >>> R = CoordSys3D('R')
+    >>> f = R.x**2*R.y**5*R.z
+    >>> laplacian(f)
+    20*R.x**2*R.y**3*R.z + 2*R.y**5*R.z
+    >>> f = R.x**2*R.i + R.y**3*R.j + R.z**4*R.k
+    >>> laplacian(f)
+    2*R.i + 6*R.y*R.j + 12*R.z**2*R.k
+
+    """
+
+    delop = Del()
+    if expr.is_Vector:
+        return (gradient(divergence(expr)) - curl(curl(expr))).doit()
+    return delop.dot(delop(expr)).doit()
+
+
+def is_conservative(field):
+    """
+    Checks if a field is conservative.
+
+    Parameters
+    ==========
+
+    field : Vector
+        The field to check for conservative property
+
+    Examples
+    ========
+
+    >>> from sympy.vector import CoordSys3D
+    >>> from sympy.vector import is_conservative
+    >>> R = CoordSys3D('R')
+    >>> is_conservative(R.y*R.z*R.i + R.x*R.z*R.j + R.x*R.y*R.k)
+    True
+    >>> is_conservative(R.z*R.j)
+    False
+
+    """
+
+    # Field is conservative irrespective of system
+    # Take the first coordinate system in the result of the
+    # separate method of Vector
+    if not isinstance(field, Vector):
+        raise TypeError("field should be a Vector")
+    if field == Vector.zero:
+        return True
+    return curl(field).simplify() == Vector.zero
+
+
+def is_solenoidal(field):
+    """
+    Checks if a field is solenoidal.
+
+    Parameters
+    ==========
+
+    field : Vector
+        The field to check for solenoidal property
+
+    Examples
+    ========
+
+    >>> from sympy.vector import CoordSys3D
+    >>> from sympy.vector import is_solenoidal
+    >>> R = CoordSys3D('R')
+    >>> is_solenoidal(R.y*R.z*R.i + R.x*R.z*R.j + R.x*R.y*R.k)
+    True
+    >>> is_solenoidal(R.y * R.j)
+    False
+
+    """
+
+    # Field is solenoidal irrespective of system
+    # Take the first coordinate system in the result of the
+    # separate method in Vector
+    if not isinstance(field, Vector):
+        raise TypeError("field should be a Vector")
+    if field == Vector.zero:
+        return True
+    return divergence(field).simplify() is S.Zero
+
+
+def scalar_potential(field, coord_sys):
+    """
+    Returns the scalar potential function of a field in a given
+    coordinate system (without the added integration constant).
+
+    Parameters
+    ==========
+
+    field : Vector
+        The vector field whose scalar potential function is to be
+        calculated
+
+    coord_sys : CoordSys3D
+        The coordinate system to do the calculation in
+
+    Examples
+    ========
+
+    >>> from sympy.vector import CoordSys3D
+    >>> from sympy.vector import scalar_potential, gradient
+    >>> R = CoordSys3D('R')
+    >>> scalar_potential(R.k, R) == R.z
+    True
+    >>> scalar_field = 2*R.x**2*R.y*R.z
+    >>> grad_field = gradient(scalar_field)
+    >>> scalar_potential(grad_field, R)
+    2*R.x**2*R.y*R.z
+
+    """
+
+    # Check whether field is conservative
+    if not is_conservative(field):
+        raise ValueError("Field is not conservative")
+    if field == Vector.zero:
+        return S.Zero
+    # Express the field exntirely in coord_sys
+    # Substitute coordinate variables also
+    if not isinstance(coord_sys, CoordSys3D):
+        raise TypeError("coord_sys must be a CoordSys3D")
+    field = express(field, coord_sys, variables=True)
+    dimensions = coord_sys.base_vectors()
+    scalars = coord_sys.base_scalars()
+    # Calculate scalar potential function
+    temp_function = integrate(field.dot(dimensions[0]), scalars[0])
+    for i, dim in enumerate(dimensions[1:]):
+        partial_diff = diff(temp_function, scalars[i + 1])
+        partial_diff = field.dot(dim) - partial_diff
+        temp_function += integrate(partial_diff, scalars[i + 1])
+    return temp_function
+
+
+def scalar_potential_difference(field, coord_sys, point1, point2):
+    """
+    Returns the scalar potential difference between two points in a
+    certain coordinate system, wrt a given field.
+
+    If a scalar field is provided, its values at the two points are
+    considered. If a conservative vector field is provided, the values
+    of its scalar potential function at the two points are used.
+
+    Returns (potential at point2) - (potential at point1)
+
+    The position vectors of the two Points are calculated wrt the
+    origin of the coordinate system provided.
+
+    Parameters
+    ==========
+
+    field : Vector/Expr
+        The field to calculate wrt
+
+    coord_sys : CoordSys3D
+        The coordinate system to do the calculations in
+
+    point1 : Point
+        The initial Point in given coordinate system
+
+    position2 : Point
+        The second Point in the given coordinate system
+
+    Examples
+    ========
+
+    >>> from sympy.vector import CoordSys3D
+    >>> from sympy.vector import scalar_potential_difference
+    >>> R = CoordSys3D('R')
+    >>> P = R.origin.locate_new('P', R.x*R.i + R.y*R.j + R.z*R.k)
+    >>> vectfield = 4*R.x*R.y*R.i + 2*R.x**2*R.j
+    >>> scalar_potential_difference(vectfield, R, R.origin, P)
+    2*R.x**2*R.y
+    >>> Q = R.origin.locate_new('O', 3*R.i + R.j + 2*R.k)
+    >>> scalar_potential_difference(vectfield, R, P, Q)
+    -2*R.x**2*R.y + 18
+
+    """
+
+    if not isinstance(coord_sys, CoordSys3D):
+        raise TypeError("coord_sys must be a CoordSys3D")
+    if isinstance(field, Vector):
+        # Get the scalar potential function
+        scalar_fn = scalar_potential(field, coord_sys)
+    else:
+        # Field is a scalar
+        scalar_fn = field
+    # Express positions in required coordinate system
+    origin = coord_sys.origin
+    position1 = express(point1.position_wrt(origin), coord_sys,
+                        variables=True)
+    position2 = express(point2.position_wrt(origin), coord_sys,
+                        variables=True)
+    # Get the two positions as substitution dicts for coordinate variables
+    subs_dict1 = {}
+    subs_dict2 = {}
+    scalars = coord_sys.base_scalars()
+    for i, x in enumerate(coord_sys.base_vectors()):
+        subs_dict1[scalars[i]] = x.dot(position1)
+        subs_dict2[scalars[i]] = x.dot(position2)
+    return scalar_fn.subs(subs_dict2) - scalar_fn.subs(subs_dict1)
+
+
+def matrix_to_vector(matrix, system):
+    """
+    Converts a vector in matrix form to a Vector instance.
+
+    It is assumed that the elements of the Matrix represent the
+    measure numbers of the components of the vector along basis
+    vectors of 'system'.
+
+    Parameters
+    ==========
+
+    matrix : SymPy Matrix, Dimensions: (3, 1)
+        The matrix to be converted to a vector
+
+    system : CoordSys3D
+        The coordinate system the vector is to be defined in
+
+    Examples
+    ========
+
+    >>> from sympy import ImmutableMatrix as Matrix
+    >>> m = Matrix([1, 2, 3])
+    >>> from sympy.vector import CoordSys3D, matrix_to_vector
+    >>> C = CoordSys3D('C')
+    >>> v = matrix_to_vector(m, C)
+    >>> v
+    C.i + 2*C.j + 3*C.k
+    >>> v.to_matrix(C) == m
+    True
+
+    """
+
+    outvec = Vector.zero
+    vects = system.base_vectors()
+    for i, x in enumerate(matrix):
+        outvec += x * vects[i]
+    return outvec
+
+
+def _path(from_object, to_object):
+    """
+    Calculates the 'path' of objects starting from 'from_object'
+    to 'to_object', along with the index of the first common
+    ancestor in the tree.
+
+    Returns (index, list) tuple.
+    """
+
+    if from_object._root != to_object._root:
+        raise ValueError("No connecting path found between " +
+                         str(from_object) + " and " + str(to_object))
+
+    other_path = []
+    obj = to_object
+    while obj._parent is not None:
+        other_path.append(obj)
+        obj = obj._parent
+    other_path.append(obj)
+    object_set = set(other_path)
+    from_path = []
+    obj = from_object
+    while obj not in object_set:
+        from_path.append(obj)
+        obj = obj._parent
+    index = len(from_path)
+    i = other_path.index(obj)
+    while i >= 0:
+        from_path.append(other_path[i])
+        i -= 1
+    return index, from_path
+
+
+def orthogonalize(*vlist, orthonormal=False):
+    """
+    Takes a sequence of independent vectors and orthogonalizes them
+    using the Gram - Schmidt process. Returns a list of
+    orthogonal or orthonormal vectors.
+
+    Parameters
+    ==========
+
+    vlist : sequence of independent vectors to be made orthogonal.
+
+    orthonormal : Optional parameter
+                  Set to True if the vectors returned should be
+                  orthonormal.
+                  Default: False
+
+    Examples
+    ========
+
+    >>> from sympy.vector.coordsysrect import CoordSys3D
+    >>> from sympy.vector.functions import orthogonalize
+    >>> C = CoordSys3D('C')
+    >>> i, j, k = C.base_vectors()
+    >>> v1 = i + 2*j
+    >>> v2 = 2*i + 3*j
+    >>> orthogonalize(v1, v2)
+    [C.i + 2*C.j, 2/5*C.i + (-1/5)*C.j]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Gram-Schmidt_process
+
+    """
+
+    if not all(isinstance(vec, Vector) for vec in vlist):
+        raise TypeError('Each element must be of Type Vector')
+
+    ortho_vlist = []
+    for i, term in enumerate(vlist):
+        for j in range(i):
+            term -= ortho_vlist[j].projection(vlist[i])
+        # TODO : The following line introduces a performance issue
+        # and needs to be changed once a good solution for issue #10279 is
+        # found.
+        if simplify(term).equals(Vector.zero):
+            raise ValueError("Vector set not linearly independent")
+        ortho_vlist.append(term)
+
+    if orthonormal:
+        ortho_vlist = [vec.normalize() for vec in ortho_vlist]
+
+    return ortho_vlist

env-llmeval/lib/python3.10/site-packages/sympy/vector/implicitregion.py

@@ -0,0 +1,506 @@
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.complexes import sign
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.polys.polytools import gcd
+from sympy.sets.sets import Complement
+from sympy.core import Basic, Tuple, diff, expand, Eq, Integer
+from sympy.core.sorting import ordered
+from sympy.core.symbol import _symbol
+from sympy.solvers import solveset, nonlinsolve, diophantine
+from sympy.polys import total_degree
+from sympy.geometry import Point
+from sympy.ntheory.factor_ import core
+
+
+class ImplicitRegion(Basic):
+    """
+    Represents an implicit region in space.
+
+    Examples
+    ========
+
+    >>> from sympy import Eq
+    >>> from sympy.abc import x, y, z, t
+    >>> from sympy.vector import ImplicitRegion
+
+    >>> ImplicitRegion((x, y), x**2 + y**2 - 4)
+    ImplicitRegion((x, y), x**2 + y**2 - 4)
+    >>> ImplicitRegion((x, y), Eq(y*x, 1))
+    ImplicitRegion((x, y), x*y - 1)
+
+    >>> parabola = ImplicitRegion((x, y), y**2 - 4*x)
+    >>> parabola.degree
+    2
+    >>> parabola.equation
+    -4*x + y**2
+    >>> parabola.rational_parametrization(t)
+    (4/t**2, 4/t)
+
+    >>> r = ImplicitRegion((x, y, z), Eq(z, x**2 + y**2))
+    >>> r.variables
+    (x, y, z)
+    >>> r.singular_points()
+    EmptySet
+    >>> r.regular_point()
+    (-10, -10, 200)
+
+    Parameters
+    ==========
+
+    variables : tuple to map variables in implicit equation to base scalars.
+
+    equation : An expression or Eq denoting the implicit equation of the region.
+
+    """
+    def __new__(cls, variables, equation):
+        if not isinstance(variables, Tuple):
+            variables = Tuple(*variables)
+
+        if isinstance(equation, Eq):
+            equation = equation.lhs - equation.rhs
+
+        return super().__new__(cls, variables, equation)
+
+    @property
+    def variables(self):
+        return self.args[0]
+
+    @property
+    def equation(self):
+        return self.args[1]
+
+    @property
+    def degree(self):
+        return total_degree(self.equation)
+
+    def regular_point(self):
+        """
+        Returns a point on the implicit region.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y, z
+        >>> from sympy.vector import ImplicitRegion
+        >>> circle = ImplicitRegion((x, y), (x + 2)**2 + (y - 3)**2 - 16)
+        >>> circle.regular_point()
+        (-2, -1)
+        >>> parabola = ImplicitRegion((x, y), x**2 - 4*y)
+        >>> parabola.regular_point()
+        (0, 0)
+        >>> r = ImplicitRegion((x, y, z), (x + y + z)**4)
+        >>> r.regular_point()
+        (-10, -10, 20)
+
+        References
+        ==========
+
+        - Erik Hillgarter, "Rational Points on Conics", Diploma Thesis, RISC-Linz,
+          J. Kepler Universitat Linz, 1996. Available:
+          https://www3.risc.jku.at/publications/download/risc_1355/Rational%20Points%20on%20Conics.pdf
+
+        """
+        equation = self.equation
+
+        if len(self.variables) == 1:
+            return (list(solveset(equation, self.variables[0], domain=S.Reals))[0],)
+        elif len(self.variables) == 2:
+
+            if self.degree == 2:
+                coeffs = a, b, c, d, e, f = conic_coeff(self.variables, equation)
+
+                if b**2 == 4*a*c:
+                    x_reg, y_reg = self._regular_point_parabola(*coeffs)
+                else:
+                    x_reg, y_reg = self._regular_point_ellipse(*coeffs)
+                return x_reg, y_reg
+
+        if len(self.variables) == 3:
+            x, y, z = self.variables
+
+            for x_reg in range(-10, 10):
+                for y_reg in range(-10, 10):
+                    if not solveset(equation.subs({x: x_reg, y: y_reg}), self.variables[2], domain=S.Reals).is_empty:
+                        return (x_reg, y_reg, list(solveset(equation.subs({x: x_reg, y: y_reg})))[0])
+
+        if len(self.singular_points()) != 0:
+            return list[self.singular_points()][0]
+
+        raise NotImplementedError()
+
+    def _regular_point_parabola(self, a, b, c, d, e, f):
+            ok = (a, d) != (0, 0) and (c, e) != (0, 0) and b**2 == 4*a*c and (a, c) != (0, 0)
+
+            if not ok:
+                raise ValueError("Rational Point on the conic does not exist")
+
+            if a != 0:
+                d_dash, f_dash = (4*a*e - 2*b*d, 4*a*f - d**2)
+                if d_dash != 0:
+                    y_reg = -f_dash/d_dash
+                    x_reg = -(d + b*y_reg)/(2*a)
+                else:
+                    ok = False
+            elif c != 0:
+                d_dash, f_dash = (4*c*d - 2*b*e, 4*c*f - e**2)
+                if d_dash != 0:
+                    x_reg = -f_dash/d_dash
+                    y_reg = -(e + b*x_reg)/(2*c)
+                else:
+                    ok = False
+
+            if ok:
+                return x_reg, y_reg
+            else:
+                raise ValueError("Rational Point on the conic does not exist")
+
+    def _regular_point_ellipse(self, a, b, c, d, e, f):
+            D = 4*a*c - b**2
+            ok = D
+
+            if not ok:
+                raise ValueError("Rational Point on the conic does not exist")
+
+            if a == 0 and c == 0:
+                K = -1
+                L = 4*(d*e - b*f)
+            elif c != 0:
+                K = D
+                L = 4*c**2*d**2 - 4*b*c*d*e + 4*a*c*e**2 + 4*b**2*c*f - 16*a*c**2*f
+            else:
+                K = D
+                L = 4*a**2*e**2 - 4*b*a*d*e + 4*b**2*a*f
+
+            ok = L != 0 and not(K > 0 and L < 0)
+            if not ok:
+                raise ValueError("Rational Point on the conic does not exist")
+
+            K = Rational(K).limit_denominator(10**12)
+            L = Rational(L).limit_denominator(10**12)
+
+            k1, k2 = K.p, K.q
+            l1, l2 = L.p, L.q
+            g = gcd(k2, l2)
+
+            a1 = (l2*k2)/g
+            b1 = (k1*l2)/g
+            c1 = -(l1*k2)/g
+            a2 = sign(a1)*core(abs(a1), 2)
+            r1 = sqrt(a1/a2)
+            b2 = sign(b1)*core(abs(b1), 2)
+            r2 = sqrt(b1/b2)
+            c2 = sign(c1)*core(abs(c1), 2)
+            r3 = sqrt(c1/c2)
+
+            g = gcd(gcd(a2, b2), c2)
+            a2 = a2/g
+            b2 = b2/g
+            c2 = c2/g
+
+            g1 = gcd(a2, b2)
+            a2 = a2/g1
+            b2 = b2/g1
+            c2 = c2*g1
+
+            g2 = gcd(a2,c2)
+            a2 = a2/g2
+            b2 = b2*g2
+            c2 = c2/g2
+
+            g3 = gcd(b2, c2)
+            a2 = a2*g3
+            b2 = b2/g3
+            c2 = c2/g3
+
+            x, y, z = symbols("x y z")
+            eq = a2*x**2 + b2*y**2 + c2*z**2
+
+            solutions = diophantine(eq)
+
+            if len(solutions) == 0:
+                raise ValueError("Rational Point on the conic does not exist")
+
+            flag = False
+            for sol in solutions:
+                syms = Tuple(*sol).free_symbols
+                rep = {s: 3 for s in syms}
+                sol_z = sol[2]
+
+                if sol_z == 0:
+                    flag = True
+                    continue
+
+                if not isinstance(sol_z, (int, Integer)):
+                    syms_z = sol_z.free_symbols
+
+                    if len(syms_z) == 1:
+                        p = next(iter(syms_z))
+                        p_values = Complement(S.Integers, solveset(Eq(sol_z, 0), p, S.Integers))
+                        rep[p] = next(iter(p_values))
+
+                    if len(syms_z) == 2:
+                        p, q = list(ordered(syms_z))
+
+                        for i in S.Integers:
+                            subs_sol_z = sol_z.subs(p, i)
+                            q_values = Complement(S.Integers, solveset(Eq(subs_sol_z, 0), q, S.Integers))
+
+                            if not q_values.is_empty:
+                                rep[p] = i
+                                rep[q] = next(iter(q_values))
+                                break
+
+                    if len(syms) != 0:
+                        x, y, z = tuple(s.subs(rep) for s in sol)
+                    else:
+                        x, y, z =   sol
+                    flag = False
+                    break
+
+            if flag:
+                raise ValueError("Rational Point on the conic does not exist")
+
+            x = (x*g3)/r1
+            y = (y*g2)/r2
+            z = (z*g1)/r3
+            x = x/z
+            y = y/z
+
+            if a == 0 and c == 0:
+                x_reg = (x + y - 2*e)/(2*b)
+                y_reg = (x - y - 2*d)/(2*b)
+            elif c != 0:
+                x_reg = (x - 2*d*c + b*e)/K
+                y_reg = (y - b*x_reg - e)/(2*c)
+            else:
+                y_reg = (x - 2*e*a + b*d)/K
+                x_reg = (y - b*y_reg - d)/(2*a)
+
+            return x_reg, y_reg
+
+    def singular_points(self):
+        """
+        Returns a set of singular points of the region.
+
+        The singular points are those points on the region
+        where all partial derivatives vanish.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> from sympy.vector import ImplicitRegion
+        >>> I = ImplicitRegion((x, y), (y-1)**2 -x**3 + 2*x**2 -x)
+        >>> I.singular_points()
+        {(1, 1)}
+
+        """
+        eq_list = [self.equation]
+        for var in self.variables:
+            eq_list += [diff(self.equation, var)]
+
+        return nonlinsolve(eq_list, list(self.variables))
+
+    def multiplicity(self, point):
+        """
+        Returns the multiplicity of a singular point on the region.
+
+        A singular point (x,y) of region is said to be of multiplicity m
+        if all the partial derivatives off to order m - 1 vanish there.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y, z
+        >>> from sympy.vector import ImplicitRegion
+        >>> I = ImplicitRegion((x, y, z), x**2 + y**3 - z**4)
+        >>> I.singular_points()
+        {(0, 0, 0)}
+        >>> I.multiplicity((0, 0, 0))
+        2
+
+        """
+        if isinstance(point, Point):
+            point = point.args
+
+        modified_eq = self.equation
+
+        for i, var in enumerate(self.variables):
+            modified_eq = modified_eq.subs(var, var + point[i])
+        modified_eq = expand(modified_eq)
+
+        if len(modified_eq.args) != 0:
+            terms = modified_eq.args
+            m = min([total_degree(term) for term in terms])
+        else:
+            terms = modified_eq
+            m = total_degree(terms)
+
+        return m
+
+    def rational_parametrization(self, parameters=('t', 's'), reg_point=None):
+        """
+        Returns the rational parametrization of implicit region.
+
+        Examples
+        ========
+
+        >>> from sympy import Eq
+        >>> from sympy.abc import x, y, z, s, t
+        >>> from sympy.vector import ImplicitRegion
+
+        >>> parabola = ImplicitRegion((x, y), y**2 - 4*x)
+        >>> parabola.rational_parametrization()
+        (4/t**2, 4/t)
+
+        >>> circle = ImplicitRegion((x, y), Eq(x**2 + y**2, 4))
+        >>> circle.rational_parametrization()
+        (4*t/(t**2 + 1), 4*t**2/(t**2 + 1) - 2)
+
+        >>> I = ImplicitRegion((x, y), x**3 + x**2 - y**2)
+        >>> I.rational_parametrization()
+        (t**2 - 1, t*(t**2 - 1))
+
+        >>> cubic_curve = ImplicitRegion((x, y), x**3 + x**2 - y**2)
+        >>> cubic_curve.rational_parametrization(parameters=(t))
+        (t**2 - 1, t*(t**2 - 1))
+
+        >>> sphere = ImplicitRegion((x, y, z), x**2 + y**2 + z**2 - 4)
+        >>> sphere.rational_parametrization(parameters=(t, s))
+        (-2 + 4/(s**2 + t**2 + 1), 4*s/(s**2 + t**2 + 1), 4*t/(s**2 + t**2 + 1))
+
+        For some conics, regular_points() is unable to find a point on curve.
+        To calulcate the parametric representation in such cases, user need
+        to determine a point on the region and pass it using reg_point.
+
+        >>> c = ImplicitRegion((x, y), (x  - 1/2)**2 + (y)**2 - (1/4)**2)
+        >>> c.rational_parametrization(reg_point=(3/4, 0))
+        (0.75 - 0.5/(t**2 + 1), -0.5*t/(t**2 + 1))
+
+        References
+        ==========
+
+        - Christoph M. Hoffmann, "Conversion Methods between Parametric and
+          Implicit Curves and Surfaces", Purdue e-Pubs, 1990. Available:
+          https://docs.lib.purdue.edu/cgi/viewcontent.cgi?article=1827&context=cstech
+
+        """
+        equation = self.equation
+        degree = self.degree
+
+        if degree == 1:
+            if len(self.variables) == 1:
+                return (equation,)
+            elif len(self.variables) == 2:
+                x, y = self.variables
+                y_par = list(solveset(equation, y))[0]
+                return x, y_par
+            else:
+                raise NotImplementedError()
+
+        point = ()
+
+        # Finding the (n - 1) fold point of the monoid of degree
+        if degree == 2:
+            # For degree 2 curves, either a regular point or a singular point can be used.
+            if reg_point is not None:
+                # Using point provided by the user as regular point
+                point = reg_point
+            else:
+                if len(self.singular_points()) != 0:
+                    point = list(self.singular_points())[0]
+                else:
+                    point = self.regular_point()
+
+        if len(self.singular_points()) != 0:
+            singular_points = self.singular_points()
+            for spoint in singular_points:
+                syms = Tuple(*spoint).free_symbols
+                rep = {s: 2 for s in syms}
+
+                if len(syms) != 0:
+                   spoint = tuple(s.subs(rep) for s in spoint)
+
+                if self.multiplicity(spoint) == degree - 1:
+                    point = spoint
+                    break
+
+        if len(point) == 0:
+            # The region in not a monoid
+            raise NotImplementedError()
+
+        modified_eq = equation
+
+        # Shifting the region such that fold point moves to origin
+        for i, var in enumerate(self.variables):
+            modified_eq = modified_eq.subs(var, var + point[i])
+        modified_eq = expand(modified_eq)
+
+        hn = hn_1 = 0
+        for term in modified_eq.args:
+            if total_degree(term) == degree:
+                hn += term
+            else:
+                hn_1 += term
+
+        hn_1 = -1*hn_1
+
+        if not isinstance(parameters, tuple):
+            parameters = (parameters,)
+
+        if len(self.variables) == 2:
+
+            parameter1 = parameters[0]
+            if parameter1 == 's':
+                # To avoid name conflict between parameters
+                s = _symbol('s_', real=True)
+            else:
+                s = _symbol('s', real=True)
+            t = _symbol(parameter1, real=True)
+
+            hn = hn.subs({self.variables[0]: s, self.variables[1]: t})
+            hn_1 = hn_1.subs({self.variables[0]: s, self.variables[1]: t})
+
+            x_par = (s*(hn_1/hn)).subs(s, 1) + point[0]
+            y_par = (t*(hn_1/hn)).subs(s, 1) + point[1]
+
+            return x_par, y_par
+
+        elif len(self.variables) == 3:
+
+            parameter1, parameter2 = parameters
+            if 'r' in parameters:
+                # To avoid name conflict between parameters
+                r = _symbol('r_', real=True)
+            else:
+                r = _symbol('r', real=True)
+            s = _symbol(parameter2, real=True)
+            t = _symbol(parameter1, real=True)
+
+            hn = hn.subs({self.variables[0]: r, self.variables[1]: s, self.variables[2]: t})
+            hn_1 = hn_1.subs({self.variables[0]: r, self.variables[1]: s, self.variables[2]: t})
+
+            x_par = (r*(hn_1/hn)).subs(r, 1) + point[0]
+            y_par = (s*(hn_1/hn)).subs(r, 1) + point[1]
+            z_par = (t*(hn_1/hn)).subs(r, 1) + point[2]
+
+            return x_par, y_par, z_par
+
+        raise NotImplementedError()
+
+def conic_coeff(variables, equation):
+    if total_degree(equation) != 2:
+        raise ValueError()
+    x = variables[0]
+    y = variables[1]
+
+    equation = expand(equation)
+    a = equation.coeff(x**2)
+    b = equation.coeff(x*y)
+    c = equation.coeff(y**2)
+    d = equation.coeff(x, 1).coeff(y, 0)
+    e = equation.coeff(y, 1).coeff(x, 0)
+    f = equation.coeff(x, 0).coeff(y, 0)
+    return a, b, c, d, e, f

env-llmeval/lib/python3.10/site-packages/sympy/vector/integrals.py

@@ -0,0 +1,206 @@
+from sympy.core import Basic, diff
+from sympy.core.singleton import S
+from sympy.core.sorting import default_sort_key
+from sympy.matrices import Matrix
+from sympy.integrals import Integral, integrate
+from sympy.geometry.entity import GeometryEntity
+from sympy.simplify.simplify import simplify
+from sympy.utilities.iterables import topological_sort
+from sympy.vector import (CoordSys3D, Vector, ParametricRegion,
+                        parametric_region_list, ImplicitRegion)
+from sympy.vector.operators import _get_coord_systems
+
+
+class ParametricIntegral(Basic):
+    """
+    Represents integral of a scalar or vector field
+    over a Parametric Region
+
+    Examples
+    ========
+
+    >>> from sympy import cos, sin, pi
+    >>> from sympy.vector import CoordSys3D, ParametricRegion, ParametricIntegral
+    >>> from sympy.abc import r, t, theta, phi
+
+    >>> C = CoordSys3D('C')
+    >>> curve = ParametricRegion((3*t - 2, t + 1), (t, 1, 2))
+    >>> ParametricIntegral(C.x, curve)
+    5*sqrt(10)/2
+    >>> length = ParametricIntegral(1, curve)
+    >>> length
+    sqrt(10)
+    >>> semisphere = ParametricRegion((2*sin(phi)*cos(theta), 2*sin(phi)*sin(theta), 2*cos(phi)),\
+                            (theta, 0, 2*pi), (phi, 0, pi/2))
+    >>> ParametricIntegral(C.z, semisphere)
+    8*pi
+
+    >>> ParametricIntegral(C.j + C.k, ParametricRegion((r*cos(theta), r*sin(theta)), r, theta))
+    0
+
+    """
+
+    def __new__(cls, field, parametricregion):
+
+        coord_set = _get_coord_systems(field)
+
+        if len(coord_set) == 0:
+            coord_sys = CoordSys3D('C')
+        elif len(coord_set) > 1:
+            raise ValueError
+        else:
+            coord_sys = next(iter(coord_set))
+
+        if parametricregion.dimensions == 0:
+            return S.Zero
+
+        base_vectors = coord_sys.base_vectors()
+        base_scalars = coord_sys.base_scalars()
+
+        parametricfield = field
+
+        r = Vector.zero
+        for i in range(len(parametricregion.definition)):
+            r += base_vectors[i]*parametricregion.definition[i]
+
+        if len(coord_set) != 0:
+            for i in range(len(parametricregion.definition)):
+                parametricfield = parametricfield.subs(base_scalars[i], parametricregion.definition[i])
+
+        if parametricregion.dimensions == 1:
+            parameter = parametricregion.parameters[0]
+
+            r_diff = diff(r, parameter)
+            lower, upper = parametricregion.limits[parameter][0], parametricregion.limits[parameter][1]
+
+            if isinstance(parametricfield, Vector):
+                integrand = simplify(r_diff.dot(parametricfield))
+            else:
+                integrand = simplify(r_diff.magnitude()*parametricfield)
+
+            result = integrate(integrand, (parameter, lower, upper))
+
+        elif parametricregion.dimensions == 2:
+            u, v = cls._bounds_case(parametricregion.parameters, parametricregion.limits)
+
+            r_u = diff(r, u)
+            r_v = diff(r, v)
+            normal_vector = simplify(r_u.cross(r_v))
+
+            if isinstance(parametricfield, Vector):
+                integrand = parametricfield.dot(normal_vector)
+            else:
+                integrand = parametricfield*normal_vector.magnitude()
+
+            integrand = simplify(integrand)
+
+            lower_u, upper_u = parametricregion.limits[u][0], parametricregion.limits[u][1]
+            lower_v, upper_v = parametricregion.limits[v][0], parametricregion.limits[v][1]
+
+            result = integrate(integrand, (u, lower_u, upper_u), (v, lower_v, upper_v))
+
+        else:
+            variables = cls._bounds_case(parametricregion.parameters, parametricregion.limits)
+            coeff = Matrix(parametricregion.definition).jacobian(variables).det()
+            integrand = simplify(parametricfield*coeff)
+
+            l = [(var, parametricregion.limits[var][0], parametricregion.limits[var][1]) for var in variables]
+            result = integrate(integrand, *l)
+
+        if not isinstance(result, Integral):
+            return result
+        else:
+            return super().__new__(cls, field, parametricregion)
+
+    @classmethod
+    def _bounds_case(cls, parameters, limits):
+
+        V = list(limits.keys())
+        E = []
+
+        for p in V:
+            lower_p = limits[p][0]
+            upper_p = limits[p][1]
+
+            lower_p = lower_p.atoms()
+            upper_p = upper_p.atoms()
+            E.extend((p, q) for q in V if p != q and
+                     (lower_p.issuperset({q}) or upper_p.issuperset({q})))
+
+        if not E:
+            return parameters
+        else:
+            return topological_sort((V, E), key=default_sort_key)
+
+    @property
+    def field(self):
+        return self.args[0]
+
+    @property
+    def parametricregion(self):
+        return self.args[1]
+
+
+def vector_integrate(field, *region):
+    """
+    Compute the integral of a vector/scalar field
+    over a a region or a set of parameters.
+
+    Examples
+    ========
+    >>> from sympy.vector import CoordSys3D, ParametricRegion, vector_integrate
+    >>> from sympy.abc import x, y, t
+    >>> C = CoordSys3D('C')
+
+    >>> region = ParametricRegion((t, t**2), (t, 1, 5))
+    >>> vector_integrate(C.x*C.i, region)
+    12
+
+    Integrals over some objects of geometry module can also be calculated.
+
+    >>> from sympy.geometry import Point, Circle, Triangle
+    >>> c = Circle(Point(0, 2), 5)
+    >>> vector_integrate(C.x**2 + C.y**2, c)
+    290*pi
+    >>> triangle = Triangle(Point(-2, 3), Point(2, 3), Point(0, 5))
+    >>> vector_integrate(3*C.x**2*C.y*C.i + C.j, triangle)
+    -8
+
+    Integrals over some simple implicit regions can be computed. But in most cases,
+    it takes too long to compute over them. This is due to the expressions of parametric
+    representation becoming large.
+
+    >>> from sympy.vector import ImplicitRegion
+    >>> c2 = ImplicitRegion((x, y), (x - 2)**2 + (y - 1)**2 - 9)
+    >>> vector_integrate(1, c2)
+    6*pi
+
+    Integral of fields with respect to base scalars:
+
+    >>> vector_integrate(12*C.y**3, (C.y, 1, 3))
+    240
+    >>> vector_integrate(C.x**2*C.z, C.x)
+    C.x**3*C.z/3
+    >>> vector_integrate(C.x*C.i - C.y*C.k, C.x)
+    (Integral(C.x, C.x))*C.i + (Integral(-C.y, C.x))*C.k
+    >>> _.doit()
+    C.x**2/2*C.i + (-C.x*C.y)*C.k
+
+    """
+    if len(region) == 1:
+        if isinstance(region[0], ParametricRegion):
+            return ParametricIntegral(field, region[0])
+
+        if isinstance(region[0], ImplicitRegion):
+            region = parametric_region_list(region[0])[0]
+            return vector_integrate(field, region)
+
+        if isinstance(region[0], GeometryEntity):
+            regions_list = parametric_region_list(region[0])
+
+            result = 0
+            for reg in regions_list:
+                result += vector_integrate(field, reg)
+            return result
+
+    return integrate(field, *region)

env-llmeval/lib/python3.10/site-packages/sympy/vector/orienters.py

@@ -0,0 +1,398 @@
+from sympy.core.basic import Basic
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.matrices.dense import (eye, rot_axis1, rot_axis2, rot_axis3)
+from sympy.matrices.immutable import ImmutableDenseMatrix as Matrix
+from sympy.core.cache import cacheit
+from sympy.core.symbol import Str
+import sympy.vector
+
+
+class Orienter(Basic):
+    """
+    Super-class for all orienter classes.
+    """
+
+    def rotation_matrix(self):
+        """
+        The rotation matrix corresponding to this orienter
+        instance.
+        """
+        return self._parent_orient
+
+
+class AxisOrienter(Orienter):
+    """
+    Class to denote an axis orienter.
+    """
+
+    def __new__(cls, angle, axis):
+        if not isinstance(axis, sympy.vector.Vector):
+            raise TypeError("axis should be a Vector")
+        angle = sympify(angle)
+
+        obj = super().__new__(cls, angle, axis)
+        obj._angle = angle
+        obj._axis = axis
+
+        return obj
+
+    def __init__(self, angle, axis):
+        """
+        Axis rotation is a rotation about an arbitrary axis by
+        some angle. The angle is supplied as a SymPy expr scalar, and
+        the axis is supplied as a Vector.
+
+        Parameters
+        ==========
+
+        angle : Expr
+            The angle by which the new system is to be rotated
+
+        axis : Vector
+            The axis around which the rotation has to be performed
+
+        Examples
+        ========
+
+        >>> from sympy.vector import CoordSys3D
+        >>> from sympy import symbols
+        >>> q1 = symbols('q1')
+        >>> N = CoordSys3D('N')
+        >>> from sympy.vector import AxisOrienter
+        >>> orienter = AxisOrienter(q1, N.i + 2 * N.j)
+        >>> B = N.orient_new('B', (orienter, ))
+
+        """
+        # Dummy initializer for docstrings
+        pass
+
+    @cacheit
+    def rotation_matrix(self, system):
+        """
+        The rotation matrix corresponding to this orienter
+        instance.
+
+        Parameters
+        ==========
+
+        system : CoordSys3D
+            The coordinate system wrt which the rotation matrix
+            is to be computed
+        """
+
+        axis = sympy.vector.express(self.axis, system).normalize()
+        axis = axis.to_matrix(system)
+        theta = self.angle
+        parent_orient = ((eye(3) - axis * axis.T) * cos(theta) +
+                         Matrix([[0, -axis[2], axis[1]],
+                                 [axis[2], 0, -axis[0]],
+                                 [-axis[1], axis[0], 0]]) * sin(theta) +
+                         axis * axis.T)
+        parent_orient = parent_orient.T
+        return parent_orient
+
+    @property
+    def angle(self):
+        return self._angle
+
+    @property
+    def axis(self):
+        return self._axis
+
+
+class ThreeAngleOrienter(Orienter):
+    """
+    Super-class for Body and Space orienters.
+    """
+
+    def __new__(cls, angle1, angle2, angle3, rot_order):
+        if isinstance(rot_order, Str):
+            rot_order = rot_order.name
+
+        approved_orders = ('123', '231', '312', '132', '213',
+                           '321', '121', '131', '212', '232',
+                           '313', '323', '')
+        original_rot_order = rot_order
+        rot_order = str(rot_order).upper()
+        if not (len(rot_order) == 3):
+            raise TypeError('rot_order should be a str of length 3')
+        rot_order = [i.replace('X', '1') for i in rot_order]
+        rot_order = [i.replace('Y', '2') for i in rot_order]
+        rot_order = [i.replace('Z', '3') for i in rot_order]
+        rot_order = ''.join(rot_order)
+        if rot_order not in approved_orders:
+            raise TypeError('Invalid rot_type parameter')
+        a1 = int(rot_order[0])
+        a2 = int(rot_order[1])
+        a3 = int(rot_order[2])
+        angle1 = sympify(angle1)
+        angle2 = sympify(angle2)
+        angle3 = sympify(angle3)
+        if cls._in_order:
+            parent_orient = (_rot(a1, angle1) *
+                             _rot(a2, angle2) *
+                             _rot(a3, angle3))
+        else:
+            parent_orient = (_rot(a3, angle3) *
+                             _rot(a2, angle2) *
+                             _rot(a1, angle1))
+        parent_orient = parent_orient.T
+
+        obj = super().__new__(
+            cls, angle1, angle2, angle3, Str(rot_order))
+        obj._angle1 = angle1
+        obj._angle2 = angle2
+        obj._angle3 = angle3
+        obj._rot_order = original_rot_order
+        obj._parent_orient = parent_orient
+
+        return obj
+
+    @property
+    def angle1(self):
+        return self._angle1
+
+    @property
+    def angle2(self):
+        return self._angle2
+
+    @property
+    def angle3(self):
+        return self._angle3
+
+    @property
+    def rot_order(self):
+        return self._rot_order
+
+
+class BodyOrienter(ThreeAngleOrienter):
+    """
+    Class to denote a body-orienter.
+    """
+
+    _in_order = True
+
+    def __new__(cls, angle1, angle2, angle3, rot_order):
+        obj = ThreeAngleOrienter.__new__(cls, angle1, angle2, angle3,
+                                         rot_order)
+        return obj
+
+    def __init__(self, angle1, angle2, angle3, rot_order):
+        """
+        Body orientation takes this coordinate system through three
+        successive simple rotations.
+
+        Body fixed rotations include both Euler Angles and
+        Tait-Bryan Angles, see https://en.wikipedia.org/wiki/Euler_angles.
+
+        Parameters
+        ==========
+
+        angle1, angle2, angle3 : Expr
+            Three successive angles to rotate the coordinate system by
+
+        rotation_order : string
+            String defining the order of axes for rotation
+
+        Examples
+        ========
+
+        >>> from sympy.vector import CoordSys3D, BodyOrienter
+        >>> from sympy import symbols
+        >>> q1, q2, q3 = symbols('q1 q2 q3')
+        >>> N = CoordSys3D('N')
+
+        A 'Body' fixed rotation is described by three angles and
+        three body-fixed rotation axes. To orient a coordinate system D
+        with respect to N, each sequential rotation is always about
+        the orthogonal unit vectors fixed to D. For example, a '123'
+        rotation will specify rotations about N.i, then D.j, then
+        D.k. (Initially, D.i is same as N.i)
+        Therefore,
+
+        >>> body_orienter = BodyOrienter(q1, q2, q3, '123')
+        >>> D = N.orient_new('D', (body_orienter, ))
+
+        is same as
+
+        >>> from sympy.vector import AxisOrienter
+        >>> axis_orienter1 = AxisOrienter(q1, N.i)
+        >>> D = N.orient_new('D', (axis_orienter1, ))
+        >>> axis_orienter2 = AxisOrienter(q2, D.j)
+        >>> D = D.orient_new('D', (axis_orienter2, ))
+        >>> axis_orienter3 = AxisOrienter(q3, D.k)
+        >>> D = D.orient_new('D', (axis_orienter3, ))
+
+        Acceptable rotation orders are of length 3, expressed in XYZ or
+        123, and cannot have a rotation about about an axis twice in a row.
+
+        >>> body_orienter1 = BodyOrienter(q1, q2, q3, '123')
+        >>> body_orienter2 = BodyOrienter(q1, q2, 0, 'ZXZ')
+        >>> body_orienter3 = BodyOrienter(0, 0, 0, 'XYX')
+
+        """
+        # Dummy initializer for docstrings
+        pass
+
+
+class SpaceOrienter(ThreeAngleOrienter):
+    """
+    Class to denote a space-orienter.
+    """
+
+    _in_order = False
+
+    def __new__(cls, angle1, angle2, angle3, rot_order):
+        obj = ThreeAngleOrienter.__new__(cls, angle1, angle2, angle3,
+                                         rot_order)
+        return obj
+
+    def __init__(self, angle1, angle2, angle3, rot_order):
+        """
+        Space rotation is similar to Body rotation, but the rotations
+        are applied in the opposite order.
+
+        Parameters
+        ==========
+
+        angle1, angle2, angle3 : Expr
+            Three successive angles to rotate the coordinate system by
+
+        rotation_order : string
+            String defining the order of axes for rotation
+
+        See Also
+        ========
+
+        BodyOrienter : Orienter to orient systems wrt Euler angles.
+
+        Examples
+        ========
+
+        >>> from sympy.vector import CoordSys3D, SpaceOrienter
+        >>> from sympy import symbols
+        >>> q1, q2, q3 = symbols('q1 q2 q3')
+        >>> N = CoordSys3D('N')
+
+        To orient a coordinate system D with respect to N, each
+        sequential rotation is always about N's orthogonal unit vectors.
+        For example, a '123' rotation will specify rotations about
+        N.i, then N.j, then N.k.
+        Therefore,
+
+        >>> space_orienter = SpaceOrienter(q1, q2, q3, '312')
+        >>> D = N.orient_new('D', (space_orienter, ))
+
+        is same as
+
+        >>> from sympy.vector import AxisOrienter
+        >>> axis_orienter1 = AxisOrienter(q1, N.i)
+        >>> B = N.orient_new('B', (axis_orienter1, ))
+        >>> axis_orienter2 = AxisOrienter(q2, N.j)
+        >>> C = B.orient_new('C', (axis_orienter2, ))
+        >>> axis_orienter3 = AxisOrienter(q3, N.k)
+        >>> D = C.orient_new('C', (axis_orienter3, ))
+
+        """
+        # Dummy initializer for docstrings
+        pass
+
+
+class QuaternionOrienter(Orienter):
+    """
+    Class to denote a quaternion-orienter.
+    """
+
+    def __new__(cls, q0, q1, q2, q3):
+        q0 = sympify(q0)
+        q1 = sympify(q1)
+        q2 = sympify(q2)
+        q3 = sympify(q3)
+        parent_orient = (Matrix([[q0 ** 2 + q1 ** 2 - q2 ** 2 -
+                                  q3 ** 2,
+                                  2 * (q1 * q2 - q0 * q3),
+                                  2 * (q0 * q2 + q1 * q3)],
+                                 [2 * (q1 * q2 + q0 * q3),
+                                  q0 ** 2 - q1 ** 2 +
+                                  q2 ** 2 - q3 ** 2,
+                                  2 * (q2 * q3 - q0 * q1)],
+                                 [2 * (q1 * q3 - q0 * q2),
+                                  2 * (q0 * q1 + q2 * q3),
+                                  q0 ** 2 - q1 ** 2 -
+                                  q2 ** 2 + q3 ** 2]]))
+        parent_orient = parent_orient.T
+
+        obj = super().__new__(cls, q0, q1, q2, q3)
+        obj._q0 = q0
+        obj._q1 = q1
+        obj._q2 = q2
+        obj._q3 = q3
+        obj._parent_orient = parent_orient
+
+        return obj
+
+    def __init__(self, angle1, angle2, angle3, rot_order):
+        """
+        Quaternion orientation orients the new CoordSys3D with
+        Quaternions, defined as a finite rotation about lambda, a unit
+        vector, by some amount theta.
+
+        This orientation is described by four parameters:
+
+        q0 = cos(theta/2)
+
+        q1 = lambda_x sin(theta/2)
+
+        q2 = lambda_y sin(theta/2)
+
+        q3 = lambda_z sin(theta/2)
+
+        Quaternion does not take in a rotation order.
+
+        Parameters
+        ==========
+
+        q0, q1, q2, q3 : Expr
+            The quaternions to rotate the coordinate system by
+
+        Examples
+        ========
+
+        >>> from sympy.vector import CoordSys3D
+        >>> from sympy import symbols
+        >>> q0, q1, q2, q3 = symbols('q0 q1 q2 q3')
+        >>> N = CoordSys3D('N')
+        >>> from sympy.vector import QuaternionOrienter
+        >>> q_orienter = QuaternionOrienter(q0, q1, q2, q3)
+        >>> B = N.orient_new('B', (q_orienter, ))
+
+        """
+        # Dummy initializer for docstrings
+        pass
+
+    @property
+    def q0(self):
+        return self._q0
+
+    @property
+    def q1(self):
+        return self._q1
+
+    @property
+    def q2(self):
+        return self._q2
+
+    @property
+    def q3(self):
+        return self._q3
+
+
+def _rot(axis, angle):
+    """DCM for simple axis 1, 2 or 3 rotations. """
+    if axis == 1:
+        return Matrix(rot_axis1(angle).T)
+    elif axis == 2:
+        return Matrix(rot_axis2(angle).T)
+    elif axis == 3:
+        return Matrix(rot_axis3(angle).T)