def test_quadratic_elliptical_case(): # Elliptical case: B**2 - 4AC < 0 assert diop_solve(42*x**2 + 8*x*y + 15*y**2 + 23*x + 17*y - 4915) == {(-11, -1)} assert diop_solve(4*x**2 + 3*y**2 + 5*x - 11*y + 12) == set([]) assert diop_solve(x**2 + y**2 + 2*x + 2*y + 2) == {(-1, -1)} assert diop_solve(15*x**2 - 9*x*y + 14*y**2 - 23*x - 14*y - 4950) == {(-15, 6)} assert diop_solve(10*x**2 + 12*x*y + 12*y**2 - 34) == \ {(-1, -1), (-1, 2), (1, -2), (1, 1)}
def test_quadratic_elliptical_case(): # Elliptical case: B**2 - 4AC < 0 # Two test cases highlighted require lot of memory due to quadratic_congruence() method. # This above method should be replaced by Pernici's square_mod() method when his PR gets merged. #assert diop_solve(42*x**2 + 8*x*y + 15*y**2 + 23*x + 17*y - 4915) == set([(-11, -1)]) assert diop_solve(4*x**2 + 3*y**2 + 5*x - 11*y + 12) == set([]) assert diop_solve(x**2 + y**2 + 2*x + 2*y + 2) == set([(-1, -1)]) #assert diop_solve(15*x**2 - 9*x*y + 14*y**2 - 23*x - 14*y - 4950) == set([(-15, 6)]) assert diop_solve(10*x**2 + 12*x*y + 12*y**2 - 34) == \ set([(-1, -1), (-1, 2), (1, -2), (1, 1)])
def test_diop_ternary_quadratic(): assert check_solutions(2*x**2 + z**2 + y**2 - 4*x*y) assert check_solutions(x**2 - y**2 - z**2 - x*y - y*z) assert check_solutions(3*x**2 - x*y - y*z - x*z) assert check_solutions(x**2 - y*z - x*z) assert check_solutions(5*x**2 - 3*x*y - x*z) assert check_solutions(4*x**2 - 5*y**2 - x*z) assert check_solutions(3*x**2 + 2*y**2 - z**2 - 2*x*y + 5*y*z - 7*y*z) assert check_solutions(8*x**2 - 12*y*z) assert check_solutions(45*x**2 - 7*y**2 - 8*x*y - z**2) assert check_solutions(x**2 - 49*y**2 - z**2 + 13*z*y -8*x*y) assert check_solutions(90*x**2 + 3*y**2 + 5*x*y + 2*z*y + 5*x*z) assert check_solutions(x**2 + 3*y**2 + z**2 - x*y - 17*y*z) assert check_solutions(x**2 + 3*y**2 + z**2 - x*y - 16*y*z + 12*x*z) assert check_solutions(x**2 + 3*y**2 + z**2 - 13*x*y - 16*y*z + 12*x*z) assert check_solutions(x*y - 7*y*z + 13*x*z) assert diop_ternary_quadratic_normal(x**2 + y**2 + z**2) == (None, None, None) assert diop_ternary_quadratic_normal(x**2 + y**2) is None raises(ValueError, lambda: _diop_ternary_quadratic_normal((x, y, z), {x*y: 1, x**2: 2, y**2: 3, z**2: 0})) eq = -2*x*y - 6*x*z + 7*y**2 - 3*y*z + 4*z**2 assert diop_ternary_quadratic(eq) == (7, 2, 0) assert diop_ternary_quadratic_normal(4*x**2 + 5*y**2 - z**2) == \ (1, 0, 2) assert diop_ternary_quadratic(x*y + 2*y*z) == \ (-2, 0, n1) eq = -5*x*y - 8*x*z - 3*y*z + 8*z**2 assert parametrize_ternary_quadratic(eq) == \ (8*p**2 - 3*p*q, -8*p*q + 8*q**2, 5*p*q) # this cannot be tested with diophantine because it will # factor into a product assert diop_solve(x*y + 2*y*z) == (-2*p*q, -n1*p**2 + p**2, p*q)
def test_diopcoverage(): eq = (2 * x + y + 1)**2 assert diop_solve(eq) == {(t_0, -2 * t_0 - 1)} eq = 2 * x**2 + 6 * x * y + 12 * x + 4 * y**2 + 18 * y + 18 assert diop_solve(eq) == {(t, -t - 3), (2 * t - 3, -t)} assert diop_quadratic(x + y**2 - 3) == {(-t**2 + 3, -t)} assert diop_linear(x + y - 3) == (t_0, 3 - t_0) assert base_solution_linear(0, 1, 2, t=None) == (0, 0) ans = (3 * t - 1, -2 * t + 1) assert base_solution_linear(4, 8, 12, t) == ans assert base_solution_linear(4, 8, 12, t=None) == tuple(_.subs(t, 0) for _ in ans) assert cornacchia(1, 1, 20) is None assert cornacchia(1, 1, 5) == {(2, 1)} assert cornacchia(1, 2, 17) == {(3, 2)} raises(ValueError, lambda: reconstruct(4, 20, 1)) assert gaussian_reduce(4, 1, 3) == (1, 1) eq = -w**2 - x**2 - y**2 + z**2 assert diop_general_pythagorean(eq) == \ diop_general_pythagorean(-eq) == \ (m1**2 + m2**2 - m3**2, 2*m1*m3, 2*m2*m3, m1**2 + m2**2 + m3**2) assert len(check_param(S(3) + x / 3, S(4) + x / 2, S(2), [x])) == 0 assert len(check_param(Rational(3, 2), S(4) + x, S(2), [x])) == 0 assert len(check_param(S(4) + x, Rational(3, 2), S(2), [x])) == 0 assert _nint_or_floor(16, 10) == 2 assert _odd(1) == (not _even(1)) == True assert _odd(0) == (not _even(0)) == False assert _remove_gcd(2, 4, 6) == (1, 2, 3) raises(TypeError, lambda: _remove_gcd((2, 4, 6))) assert sqf_normal(2*3**2*5, 2*5*11, 2*7**2*11) == \ (11, 1, 5) # it's ok if these pass some day when the solvers are implemented raises(NotImplementedError, lambda: diophantine(x**2 + y**2 + x * y + 2 * y * z - 12)) raises(NotImplementedError, lambda: diophantine(x**3 + y**2)) assert diop_quadratic(x**2 + y**2 - 1**2 - 3**4) == \ {(-9, -1), (-9, 1), (-1, -9), (-1, 9), (1, -9), (1, 9), (9, -1), (9, 1)}
def test_diop_sum_of_even_powers(): eq = x ** 4 + y ** 4 + z ** 4 - 2673 assert diop_solve(eq) == {(3, 6, 6), (2, 4, 7)} assert diop_general_sum_of_even_powers(eq, 2) == {(3, 6, 6), (2, 4, 7)} raises(NotImplementedError, lambda: diop_general_sum_of_even_powers(-eq, 2)) neg = symbols("neg", negative=True) eq = x ** 4 + y ** 4 + neg ** 4 - 2673 assert diop_general_sum_of_even_powers(eq) == {(-3, 6, 6)} assert diophantine(x ** 4 + y ** 4 + 2) == set() assert diop_general_sum_of_even_powers(x ** 4 + y ** 4 - 2, limit=0) == set()
def test_quadratic_simple_hyperbolic_case(): # Simple Hyperbolic case: A = C = 0 and B != 0 assert diop_solve(3*x*y + 34*x - 12*y + 1) == \ {(-133, -11), (5, -57)} assert diop_solve(6*x*y + 2*x + 3*y + 1) == set([]) assert diop_solve(-13*x*y + 2*x - 4*y - 54) == {(27, 0)} assert diop_solve(-27*x*y - 30*x - 12*y - 54) == {(-14, -1)} assert diop_solve(2*x*y + 5*x + 56*y + 7) == {(-161, -3), (-47, -6), (-35, -12), (-29, -69), (-27, 64), (-21, 7), (-9, 1), (105, -2)} assert diop_solve(6*x*y + 9*x + 2*y + 3) == set([]) assert diop_solve(x*y + x + y + 1) == {(-1, t), (t, -1)} assert diophantine(48*x*y)
def test_univariate(): assert diop_solve((x - 1) * (x - 2) ** 2) == {(1,), (2,)} assert diop_solve((x - 1) * (x - 2)) == {(1,), (2,)}
def test_linear(): assert diop_solve(x) == (0,) assert diop_solve(1 * x) == (0,) assert diop_solve(3 * x) == (0,) assert diop_solve(x + 1) == (-1,) assert diop_solve(2 * x + 1) == (None,) assert diop_solve(2 * x + 4) == (-2,) assert diop_solve(y + x) == (t_0, -t_0) assert diop_solve(y + x + 0) == (t_0, -t_0) assert diop_solve(y + x - 0) == (t_0, -t_0) assert diop_solve(0 * x - y - 5) == (-5,) assert diop_solve(3 * y + 2 * x - 5) == (3 * t_0 - 5, -2 * t_0 + 5) assert diop_solve(2 * x - 3 * y - 5) == (3 * t_0 - 5, 2 * t_0 - 5) assert diop_solve(-2 * x - 3 * y - 5) == (3 * t_0 + 5, -2 * t_0 - 5) assert diop_solve(7 * x + 5 * y) == (5 * t_0, -7 * t_0) assert diop_solve(2 * x + 4 * y) == (2 * t_0, -t_0) assert diop_solve(4 * x + 6 * y - 4) == (3 * t_0 - 2, -2 * t_0 + 2) assert diop_solve(4 * x + 6 * y - 3) == (None, None) assert diop_solve(0 * x + 3 * y - 4 * z + 5) == (4 * t_0 + 5, 3 * t_0 + 5) assert diop_solve(4 * x + 3 * y - 4 * z + 5) == ( t_0, 8 * t_0 + 4 * t_1 + 5, 7 * t_0 + 3 * t_1 + 5, ) assert diop_solve(4 * x + 3 * y - 4 * z + 5, None) == (0, 5, 5) assert diop_solve(4 * x + 2 * y + 8 * z - 5) == (None, None, None) assert diop_solve(5 * x + 7 * y - 2 * z - 6) == ( t_0, -3 * t_0 + 2 * t_1 + 6, -8 * t_0 + 7 * t_1 + 18, ) assert diop_solve(3 * x - 6 * y + 12 * z - 9) == (2 * t_0 + 3, t_0 + 2 * t_1, t_1) assert diop_solve(6 * w + 9 * x + 20 * y - z) == ( t_0, t_1, t_1 + t_2, 6 * t_0 + 29 * t_1 + 20 * t_2, ) # to ignore constant factors, use diophantine raises(TypeError, lambda: diop_solve(x / 2))
x1, x2, t_0 = symbols('x1 x2 t_0') input = "7,13,x,x,59,x,31,19" data = list((-i, int(char)) for i, char in enumerate(input.split(",")) if char != 'x') print(data) # a x1 + b = c x2 + d # 7 * x1 = 13 * x2 + 1 b, a = data[0] d, c = data[1] solved = diop_solve(a*x1 + b - d - c*x2) print(solved) # (13*t_0 + 2, 7*t_0 + 1) reintegrated = a*solved[0] + b print(reintegrated) # 91*t_0 + 14 a = reintegrated.args[1].args[0] b = reintegrated.args[0] d, c = data[2] solved = diop_solve(a*x1 + b - d - c*x2) print(solved) reintegrated = a*solved[0] + b print(reintegrated)
def test_univariate(): assert diop_solve((x - 1)*(x - 2)**2) == set([(1,), (2,)]) assert diop_solve((x - 1)*(x - 2)) == set([(1,), (2,)])