diff --git a/.gitattributes b/.gitattributes
index d7472fa2f9c08bd1644c0fcef65f536f5b945141..5dbac8de6ef406da18f85a1c0191ec46fa04da4a 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1134,3 +1134,10 @@ infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/arrays.cpython-310-x86_64
infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/parsers.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
infer_4_37_2/lib/python3.10/site-packages/nvidia/curand/lib/libcurand.so.10 filter=lfs diff=lfs merge=lfs -text
infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/algos.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/groupby.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/hashing.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/index.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/tslib.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/missing.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/lib.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+janus/lib/python3.10/site-packages/sympy/matrices/tests/__pycache__/test_matrixbase.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
diff --git a/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/groupby.cpython-310-x86_64-linux-gnu.so b/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/groupby.cpython-310-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..fcf797d3d8391499d72c6177bd2d24b296283aa1
--- /dev/null
+++ b/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/groupby.cpython-310-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41230fbdf558575fed8f6530dbc235130d3792987366204e2c417b04eb0da552
+size 2601544
diff --git a/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/hashing.cpython-310-x86_64-linux-gnu.so b/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/hashing.cpython-310-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..1d2b15761a139c79cb25c6d139f6466292c90949
--- /dev/null
+++ b/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/hashing.cpython-310-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aaa580f281abd4927103eb650b5862847f009d36cac26208f065eafec29d2fa4
+size 221160
diff --git a/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/index.cpython-310-x86_64-linux-gnu.so b/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/index.cpython-310-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..5f27c39598d6f57f5ee68f6d70d6ca7c94dcdeb7
--- /dev/null
+++ b/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/index.cpython-310-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7c4ebb97b90fed30f3c3a62d1b4157dd99a13aad68363e8f4362f30baa1ba3c
+size 988040
diff --git a/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/lib.cpython-310-x86_64-linux-gnu.so b/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/lib.cpython-310-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..03abc2d398db064c6c47eb0bc5ed52a89d1cc826
--- /dev/null
+++ b/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/lib.cpython-310-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:524c92ee2ccb5583f8ca8adac91ae0afa3f43db0ea0456ab0aece9ccacb87273
+size 933480
diff --git a/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/missing.cpython-310-x86_64-linux-gnu.so b/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/missing.cpython-310-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..10ef12d555f1d66614d36c8767de42ec46b29433
--- /dev/null
+++ b/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/missing.cpython-310-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe110ce6b3b10095c1c4c2f7745c02223aec6fcd4aa6cbc6782f83df72e77620
+size 211400
diff --git a/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/ops_dispatch.cpython-310-x86_64-linux-gnu.so b/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/ops_dispatch.cpython-310-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..83719ed83207c86fd97f53e3d2fb229a6e6a5560
Binary files /dev/null and b/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/ops_dispatch.cpython-310-x86_64-linux-gnu.so differ
diff --git a/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/reshape.pyi b/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/reshape.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..110687fcd0c313c45e8b025083fa5790fb9913b1
--- /dev/null
+++ b/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/reshape.pyi
@@ -0,0 +1,16 @@
+import numpy as np
+
+from pandas._typing import npt
+
+def unstack(
+ values: np.ndarray, # reshape_t[:, :]
+ mask: np.ndarray, # const uint8_t[:]
+ stride: int,
+ length: int,
+ width: int,
+ new_values: np.ndarray, # reshape_t[:, :]
+ new_mask: np.ndarray, # uint8_t[:, :]
+) -> None: ...
+def explode(
+ values: npt.NDArray[np.object_],
+) -> tuple[npt.NDArray[np.object_], npt.NDArray[np.int64]]: ...
diff --git a/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/tslib.cpython-310-x86_64-linux-gnu.so b/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/tslib.cpython-310-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..f2f11e11d4a40f90336595896dde8e27f11d5caa
--- /dev/null
+++ b/infer_4_37_2/lib/python3.10/site-packages/pandas/_libs/tslib.cpython-310-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f28ec212e94a75d6066e383be4243e1317de1339e61ad445b8a79f0aed216136
+size 340264
diff --git a/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/__init__.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..537e3a03e40cb5863390de1f4bc1af2c04d9e4bd
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/__init__.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/fp_groups.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/fp_groups.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c84d0a4787009d4848e40358640040b5a767e989
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/fp_groups.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/galois.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/galois.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..77d241b8084239af98b1172a990a99f6e51f4faa
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/galois.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/graycode.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/graycode.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bfa031f9c6ba3c955b31f98e24a3e0df203711b8
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/graycode.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/group_numbers.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/group_numbers.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7bd0e5e23c7b17bf2aa560306574d8d468e955ba
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/group_numbers.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/partitions.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/partitions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..774151890f3ad1c363ccd3dddc91c889e6fcf4f2
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/partitions.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/pc_groups.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/pc_groups.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ff659330e41671f9f619946778c37ae19e60c0a3
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/pc_groups.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/permutations.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/permutations.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5508a819053b1454743cc462c8b9ad39ac00db1a
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/permutations.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/polyhedron.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/polyhedron.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..64d31f0e325eac8ba97f9eff913d8d2359bb1292
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/polyhedron.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/rewritingsystem_fsm.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/rewritingsystem_fsm.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6c5f1717bae719451697849f7f631b9281e20dfa
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/rewritingsystem_fsm.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/tensor_can.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/tensor_can.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e917b3b47107689483d52dc1012e84387e24f821
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/tensor_can.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/testutil.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/testutil.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ab3ee95b0542bfbadbed426db60ae14e997cfc1a
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/testutil.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/util.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/util.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8caa856217af6a416ea40786287dde130094748a
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/combinatorics/__pycache__/util.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_coset_table.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_coset_table.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..21763225b255ebce8a73916a43c2506a81eb010e
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_coset_table.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_group_numbers.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_group_numbers.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9d7f1c58ff8663f2feb1f78fb532d608ca2719ba
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_group_numbers.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_util.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_util.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e87f0b6b12389e56576a82f2316d37ed99c2fb4c
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/combinatorics/tests/__pycache__/test_util.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/concrete/guess.py b/janus/lib/python3.10/site-packages/sympy/concrete/guess.py
new file mode 100644
index 0000000000000000000000000000000000000000..f3974485d7cfe16ca2338797d00acf04c3aadfb6
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/concrete/guess.py
@@ -0,0 +1,473 @@
+"""Various algorithms for helping identifying numbers and sequences."""
+
+
+from sympy.concrete.products import (Product, product)
+from sympy.core import Function, S
+from sympy.core.add import Add
+from sympy.core.numbers import Integer, Rational
+from sympy.core.symbol import Symbol, symbols
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.integers import floor
+from sympy.integrals.integrals import integrate
+from sympy.polys.polyfuncs import rational_interpolate as rinterp
+from sympy.polys.polytools import lcm
+from sympy.simplify.radsimp import denom
+from sympy.utilities import public
+
+
+@public
+def find_simple_recurrence_vector(l):
+ """
+ This function is used internally by other functions from the
+ sympy.concrete.guess module. While most users may want to rather use the
+ function find_simple_recurrence when looking for recurrence relations
+ among rational numbers, the current function may still be useful when
+ some post-processing has to be done.
+
+ Explanation
+ ===========
+
+ The function returns a vector of length n when a recurrence relation of
+ order n is detected in the sequence of rational numbers v.
+
+ If the returned vector has a length 1, then the returned value is always
+ the list [0], which means that no relation has been found.
+
+ While the functions is intended to be used with rational numbers, it should
+ work for other kinds of real numbers except for some cases involving
+ quadratic numbers; for that reason it should be used with some caution when
+ the argument is not a list of rational numbers.
+
+ Examples
+ ========
+
+ >>> from sympy.concrete.guess import find_simple_recurrence_vector
+ >>> from sympy import fibonacci
+ >>> find_simple_recurrence_vector([fibonacci(k) for k in range(12)])
+ [1, -1, -1]
+
+ See Also
+ ========
+
+ See the function sympy.concrete.guess.find_simple_recurrence which is more
+ user-friendly.
+
+ """
+ q1 = [0]
+ q2 = [1]
+ b, z = 0, len(l) >> 1
+ while len(q2) <= z:
+ while l[b]==0:
+ b += 1
+ if b == len(l):
+ c = 1
+ for x in q2:
+ c = lcm(c, denom(x))
+ if q2[0]*c < 0: c = -c
+ for k in range(len(q2)):
+ q2[k] = int(q2[k]*c)
+ return q2
+ a = S.One/l[b]
+ m = [a]
+ for k in range(b+1, len(l)):
+ m.append(-sum(l[j+1]*m[b-j-1] for j in range(b, k))*a)
+ l, m = m, [0] * max(len(q2), b+len(q1))
+ for k, q in enumerate(q2):
+ m[k] = a*q
+ for k, q in enumerate(q1):
+ m[k+b] += q
+ while m[-1]==0: m.pop() # because trailing zeros can occur
+ q1, q2, b = q2, m, 1
+ return [0]
+
+@public
+def find_simple_recurrence(v, A=Function('a'), N=Symbol('n')):
+ """
+ Detects and returns a recurrence relation from a sequence of several integer
+ (or rational) terms. The name of the function in the returned expression is
+ 'a' by default; the main variable is 'n' by default. The smallest index in
+ the returned expression is always n (and never n-1, n-2, etc.).
+
+ Examples
+ ========
+
+ >>> from sympy.concrete.guess import find_simple_recurrence
+ >>> from sympy import fibonacci
+ >>> find_simple_recurrence([fibonacci(k) for k in range(12)])
+ -a(n) - a(n + 1) + a(n + 2)
+
+ >>> from sympy import Function, Symbol
+ >>> a = [1, 1, 1]
+ >>> for k in range(15): a.append(5*a[-1]-3*a[-2]+8*a[-3])
+ >>> find_simple_recurrence(a, A=Function('f'), N=Symbol('i'))
+ -8*f(i) + 3*f(i + 1) - 5*f(i + 2) + f(i + 3)
+
+ """
+ p = find_simple_recurrence_vector(v)
+ n = len(p)
+ if n <= 1: return S.Zero
+
+ return Add(*[A(N+n-1-k)*p[k] for k in range(n)])
+
+
+@public
+def rationalize(x, maxcoeff=10000):
+ """
+ Helps identifying a rational number from a float (or mpmath.mpf) value by
+ using a continued fraction. The algorithm stops as soon as a large partial
+ quotient is detected (greater than 10000 by default).
+
+ Examples
+ ========
+
+ >>> from sympy.concrete.guess import rationalize
+ >>> from mpmath import cos, pi
+ >>> rationalize(cos(pi/3))
+ 1/2
+
+ >>> from mpmath import mpf
+ >>> rationalize(mpf("0.333333333333333"))
+ 1/3
+
+ While the function is rather intended to help 'identifying' rational
+ values, it may be used in some cases for approximating real numbers.
+ (Though other functions may be more relevant in that case.)
+
+ >>> rationalize(pi, maxcoeff = 250)
+ 355/113
+
+ See Also
+ ========
+
+ Several other methods can approximate a real number as a rational, like:
+
+ * fractions.Fraction.from_decimal
+ * fractions.Fraction.from_float
+ * mpmath.identify
+ * mpmath.pslq by using the following syntax: mpmath.pslq([x, 1])
+ * mpmath.findpoly by using the following syntax: mpmath.findpoly(x, 1)
+ * sympy.simplify.nsimplify (which is a more general function)
+
+ The main difference between the current function and all these variants is
+ that control focuses on magnitude of partial quotients here rather than on
+ global precision of the approximation. If the real is "known to be" a
+ rational number, the current function should be able to detect it correctly
+ with the default settings even when denominator is great (unless its
+ expansion contains unusually big partial quotients) which may occur
+ when studying sequences of increasing numbers. If the user cares more
+ on getting simple fractions, other methods may be more convenient.
+
+ """
+ p0, p1 = 0, 1
+ q0, q1 = 1, 0
+ a = floor(x)
+ while a < maxcoeff or q1==0:
+ p = a*p1 + p0
+ q = a*q1 + q0
+ p0, p1 = p1, p
+ q0, q1 = q1, q
+ if x==a: break
+ x = 1/(x-a)
+ a = floor(x)
+ return sympify(p) / q
+
+
+@public
+def guess_generating_function_rational(v, X=Symbol('x')):
+ """
+ Tries to "guess" a rational generating function for a sequence of rational
+ numbers v.
+
+ Examples
+ ========
+
+ >>> from sympy.concrete.guess import guess_generating_function_rational
+ >>> from sympy import fibonacci
+ >>> l = [fibonacci(k) for k in range(5,15)]
+ >>> guess_generating_function_rational(l)
+ (3*x + 5)/(-x**2 - x + 1)
+
+ See Also
+ ========
+
+ sympy.series.approximants
+ mpmath.pade
+
+ """
+ # a) compute the denominator as q
+ q = find_simple_recurrence_vector(v)
+ n = len(q)
+ if n <= 1: return None
+ # b) compute the numerator as p
+ p = [sum(v[i-k]*q[k] for k in range(min(i+1, n)))
+ for i in range(len(v)>>1)]
+ return (sum(p[k]*X**k for k in range(len(p)))
+ / sum(q[k]*X**k for k in range(n)))
+
+
+@public
+def guess_generating_function(v, X=Symbol('x'), types=['all'], maxsqrtn=2):
+ """
+ Tries to "guess" a generating function for a sequence of rational numbers v.
+ Only a few patterns are implemented yet.
+
+ Explanation
+ ===========
+
+ The function returns a dictionary where keys are the name of a given type of
+ generating function. Six types are currently implemented:
+
+ type | formal definition
+ -------+----------------------------------------------------------------
+ ogf | f(x) = Sum( a_k * x^k , k: 0..infinity )
+ egf | f(x) = Sum( a_k * x^k / k! , k: 0..infinity )
+ lgf | f(x) = Sum( (-1)^(k+1) a_k * x^k / k , k: 1..infinity )
+ | (with initial index being hold as 1 rather than 0)
+ hlgf | f(x) = Sum( a_k * x^k / k , k: 1..infinity )
+ | (with initial index being hold as 1 rather than 0)
+ lgdogf | f(x) = derivate( log(Sum( a_k * x^k, k: 0..infinity )), x)
+ lgdegf | f(x) = derivate( log(Sum( a_k * x^k / k!, k: 0..infinity )), x)
+
+ In order to spare time, the user can select only some types of generating
+ functions (default being ['all']). While forgetting to use a list in the
+ case of a single type may seem to work most of the time as in: types='ogf'
+ this (convenient) syntax may lead to unexpected extra results in some cases.
+
+ Discarding a type when calling the function does not mean that the type will
+ not be present in the returned dictionary; it only means that no extra
+ computation will be performed for that type, but the function may still add
+ it in the result when it can be easily converted from another type.
+
+ Two generating functions (lgdogf and lgdegf) are not even computed if the
+ initial term of the sequence is 0; it may be useful in that case to try
+ again after having removed the leading zeros.
+
+ Examples
+ ========
+
+ >>> from sympy.concrete.guess import guess_generating_function as ggf
+ >>> ggf([k+1 for k in range(12)], types=['ogf', 'lgf', 'hlgf'])
+ {'hlgf': 1/(1 - x), 'lgf': 1/(x + 1), 'ogf': 1/(x**2 - 2*x + 1)}
+
+ >>> from sympy import sympify
+ >>> l = sympify("[3/2, 11/2, 0, -121/2, -363/2, 121]")
+ >>> ggf(l)
+ {'ogf': (x + 3/2)/(11*x**2 - 3*x + 1)}
+
+ >>> from sympy import fibonacci
+ >>> ggf([fibonacci(k) for k in range(5, 15)], types=['ogf'])
+ {'ogf': (3*x + 5)/(-x**2 - x + 1)}
+
+ >>> from sympy import factorial
+ >>> ggf([factorial(k) for k in range(12)], types=['ogf', 'egf', 'lgf'])
+ {'egf': 1/(1 - x)}
+
+ >>> ggf([k+1 for k in range(12)], types=['egf'])
+ {'egf': (x + 1)*exp(x), 'lgdegf': (x + 2)/(x + 1)}
+
+ N-th root of a rational function can also be detected (below is an example
+ coming from the sequence A108626 from https://oeis.org).
+ The greatest n-th root to be tested is specified as maxsqrtn (default 2).
+
+ >>> ggf([1, 2, 5, 14, 41, 124, 383, 1200, 3799, 12122, 38919])['ogf']
+ sqrt(1/(x**4 + 2*x**2 - 4*x + 1))
+
+ References
+ ==========
+
+ .. [1] "Concrete Mathematics", R.L. Graham, D.E. Knuth, O. Patashnik
+ .. [2] https://oeis.org/wiki/Generating_functions
+
+ """
+ # List of all types of all g.f. known by the algorithm
+ if 'all' in types:
+ types = ('ogf', 'egf', 'lgf', 'hlgf', 'lgdogf', 'lgdegf')
+
+ result = {}
+
+ # Ordinary Generating Function (ogf)
+ if 'ogf' in types:
+ # Perform some convolutions of the sequence with itself
+ t = [1] + [0]*(len(v) - 1)
+ for d in range(max(1, maxsqrtn)):
+ t = [sum(t[n-i]*v[i] for i in range(n+1)) for n in range(len(v))]
+ g = guess_generating_function_rational(t, X=X)
+ if g:
+ result['ogf'] = g**Rational(1, d+1)
+ break
+
+ # Exponential Generating Function (egf)
+ if 'egf' in types:
+ # Transform sequence (division by factorial)
+ w, f = [], S.One
+ for i, k in enumerate(v):
+ f *= i if i else 1
+ w.append(k/f)
+ # Perform some convolutions of the sequence with itself
+ t = [1] + [0]*(len(w) - 1)
+ for d in range(max(1, maxsqrtn)):
+ t = [sum(t[n-i]*w[i] for i in range(n+1)) for n in range(len(w))]
+ g = guess_generating_function_rational(t, X=X)
+ if g:
+ result['egf'] = g**Rational(1, d+1)
+ break
+
+ # Logarithmic Generating Function (lgf)
+ if 'lgf' in types:
+ # Transform sequence (multiplication by (-1)^(n+1) / n)
+ w, f = [], S.NegativeOne
+ for i, k in enumerate(v):
+ f = -f
+ w.append(f*k/Integer(i+1))
+ # Perform some convolutions of the sequence with itself
+ t = [1] + [0]*(len(w) - 1)
+ for d in range(max(1, maxsqrtn)):
+ t = [sum(t[n-i]*w[i] for i in range(n+1)) for n in range(len(w))]
+ g = guess_generating_function_rational(t, X=X)
+ if g:
+ result['lgf'] = g**Rational(1, d+1)
+ break
+
+ # Hyperbolic logarithmic Generating Function (hlgf)
+ if 'hlgf' in types:
+ # Transform sequence (division by n+1)
+ w = []
+ for i, k in enumerate(v):
+ w.append(k/Integer(i+1))
+ # Perform some convolutions of the sequence with itself
+ t = [1] + [0]*(len(w) - 1)
+ for d in range(max(1, maxsqrtn)):
+ t = [sum(t[n-i]*w[i] for i in range(n+1)) for n in range(len(w))]
+ g = guess_generating_function_rational(t, X=X)
+ if g:
+ result['hlgf'] = g**Rational(1, d+1)
+ break
+
+ # Logarithmic derivative of ordinary generating Function (lgdogf)
+ if v[0] != 0 and ('lgdogf' in types
+ or ('ogf' in types and 'ogf' not in result)):
+ # Transform sequence by computing f'(x)/f(x)
+ # because log(f(x)) = integrate( f'(x)/f(x) )
+ a, w = sympify(v[0]), []
+ for n in range(len(v)-1):
+ w.append(
+ (v[n+1]*(n+1) - sum(w[-i-1]*v[i+1] for i in range(n)))/a)
+ # Perform some convolutions of the sequence with itself
+ t = [1] + [0]*(len(w) - 1)
+ for d in range(max(1, maxsqrtn)):
+ t = [sum(t[n-i]*w[i] for i in range(n+1)) for n in range(len(w))]
+ g = guess_generating_function_rational(t, X=X)
+ if g:
+ result['lgdogf'] = g**Rational(1, d+1)
+ if 'ogf' not in result:
+ result['ogf'] = exp(integrate(result['lgdogf'], X))
+ break
+
+ # Logarithmic derivative of exponential generating Function (lgdegf)
+ if v[0] != 0 and ('lgdegf' in types
+ or ('egf' in types and 'egf' not in result)):
+ # Transform sequence / step 1 (division by factorial)
+ z, f = [], S.One
+ for i, k in enumerate(v):
+ f *= i if i else 1
+ z.append(k/f)
+ # Transform sequence / step 2 by computing f'(x)/f(x)
+ # because log(f(x)) = integrate( f'(x)/f(x) )
+ a, w = z[0], []
+ for n in range(len(z)-1):
+ w.append(
+ (z[n+1]*(n+1) - sum(w[-i-1]*z[i+1] for i in range(n)))/a)
+ # Perform some convolutions of the sequence with itself
+ t = [1] + [0]*(len(w) - 1)
+ for d in range(max(1, maxsqrtn)):
+ t = [sum(t[n-i]*w[i] for i in range(n+1)) for n in range(len(w))]
+ g = guess_generating_function_rational(t, X=X)
+ if g:
+ result['lgdegf'] = g**Rational(1, d+1)
+ if 'egf' not in result:
+ result['egf'] = exp(integrate(result['lgdegf'], X))
+ break
+
+ return result
+
+
+@public
+def guess(l, all=False, evaluate=True, niter=2, variables=None):
+ """
+ This function is adapted from the Rate.m package for Mathematica
+ written by Christian Krattenthaler.
+ It tries to guess a formula from a given sequence of rational numbers.
+
+ Explanation
+ ===========
+
+ In order to speed up the process, the 'all' variable is set to False by
+ default, stopping the computation as some results are returned during an
+ iteration; the variable can be set to True if more iterations are needed
+ (other formulas may be found; however they may be equivalent to the first
+ ones).
+
+ Another option is the 'evaluate' variable (default is True); setting it
+ to False will leave the involved products unevaluated.
+
+ By default, the number of iterations is set to 2 but a greater value (up
+ to len(l)-1) can be specified with the optional 'niter' variable.
+ More and more convoluted results are found when the order of the
+ iteration gets higher:
+
+ * first iteration returns polynomial or rational functions;
+ * second iteration returns products of rising factorials and their
+ inverses;
+ * third iteration returns products of products of rising factorials
+ and their inverses;
+ * etc.
+
+ The returned formulas contain symbols i0, i1, i2, ... where the main
+ variables is i0 (and auxiliary variables are i1, i2, ...). A list of
+ other symbols can be provided in the 'variables' option; the length of
+ the least should be the value of 'niter' (more is acceptable but only
+ the first symbols will be used); in this case, the main variable will be
+ the first symbol in the list.
+
+ Examples
+ ========
+
+ >>> from sympy.concrete.guess import guess
+ >>> guess([1,2,6,24,120], evaluate=False)
+ [Product(i1 + 1, (i1, 1, i0 - 1))]
+
+ >>> from sympy import symbols
+ >>> r = guess([1,2,7,42,429,7436,218348,10850216], niter=4)
+ >>> i0 = symbols("i0")
+ >>> [r[0].subs(i0,n).doit() for n in range(1,10)]
+ [1, 2, 7, 42, 429, 7436, 218348, 10850216, 911835460]
+ """
+ if any(a==0 for a in l[:-1]):
+ return []
+ N = len(l)
+ niter = min(N-1, niter)
+ myprod = product if evaluate else Product
+ g = []
+ res = []
+ if variables is None:
+ symb = symbols('i:'+str(niter))
+ else:
+ symb = variables
+ for k, s in enumerate(symb):
+ g.append(l)
+ n, r = len(l), []
+ for i in range(n-2-1, -1, -1):
+ ri = rinterp(enumerate(g[k][:-1], start=1), i, X=s)
+ if ((denom(ri).subs({s:n}) != 0)
+ and (ri.subs({s:n}) - g[k][-1] == 0)
+ and ri not in r):
+ r.append(ri)
+ if r:
+ for i in range(k-1, -1, -1):
+ r = [g[i][0]
+ * myprod(v, (symb[i+1], 1, symb[i]-1)) for v in r]
+ if not all: return r
+ res += r
+ l = [Rational(l[i+1], l[i]) for i in range(N-k-1)]
+ return res
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/__init__.py b/janus/lib/python3.10/site-packages/sympy/geometry/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb85d4ff5d53eb44a039a95cfc2fff687322cc76
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/geometry/__init__.py
@@ -0,0 +1,45 @@
+"""
+A geometry module for the SymPy library. This module contains all of the
+entities and functions needed to construct basic geometrical data and to
+perform simple informational queries.
+
+Usage:
+======
+
+Examples
+========
+
+"""
+from sympy.geometry.point import Point, Point2D, Point3D
+from sympy.geometry.line import Line, Ray, Segment, Line2D, Segment2D, Ray2D, \
+ Line3D, Segment3D, Ray3D
+from sympy.geometry.plane import Plane
+from sympy.geometry.ellipse import Ellipse, Circle
+from sympy.geometry.polygon import Polygon, RegularPolygon, Triangle, rad, deg
+from sympy.geometry.util import are_similar, centroid, convex_hull, idiff, \
+ intersection, closest_points, farthest_points
+from sympy.geometry.exceptions import GeometryError
+from sympy.geometry.curve import Curve
+from sympy.geometry.parabola import Parabola
+
+__all__ = [
+ 'Point', 'Point2D', 'Point3D',
+
+ 'Line', 'Ray', 'Segment', 'Line2D', 'Segment2D', 'Ray2D', 'Line3D',
+ 'Segment3D', 'Ray3D',
+
+ 'Plane',
+
+ 'Ellipse', 'Circle',
+
+ 'Polygon', 'RegularPolygon', 'Triangle', 'rad', 'deg',
+
+ 'are_similar', 'centroid', 'convex_hull', 'idiff', 'intersection',
+ 'closest_points', 'farthest_points',
+
+ 'GeometryError',
+
+ 'Curve',
+
+ 'Parabola',
+]
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/__pycache__/curve.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/geometry/__pycache__/curve.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..39a2be0ad4b44d3f5d283fa4b62398e373fb92fd
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/geometry/__pycache__/curve.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/__pycache__/ellipse.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/geometry/__pycache__/ellipse.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..53c261c560bc0a5661238fb72e20c238f28a8395
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/geometry/__pycache__/ellipse.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/__pycache__/line.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/geometry/__pycache__/line.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..913bbdced7c49a68adafc5dc9dc239283f792bbd
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/geometry/__pycache__/line.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/__pycache__/parabola.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/geometry/__pycache__/parabola.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8034abd4e0f615f79a618009797c8f1bf039f6d1
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/geometry/__pycache__/parabola.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/__pycache__/plane.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/geometry/__pycache__/plane.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f0f2d50eb39da711ae1570fc2a408333be539a76
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/geometry/__pycache__/plane.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/curve.py b/janus/lib/python3.10/site-packages/sympy/geometry/curve.py
new file mode 100644
index 0000000000000000000000000000000000000000..c074f22cad79b1261ad44be4ccface972cdd3b82
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/geometry/curve.py
@@ -0,0 +1,424 @@
+"""Curves in 2-dimensional Euclidean space.
+
+Contains
+========
+Curve
+
+"""
+
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core import diff
+from sympy.core.containers import Tuple
+from sympy.core.symbol import _symbol
+from sympy.geometry.entity import GeometryEntity, GeometrySet
+from sympy.geometry.point import Point
+from sympy.integrals import integrate
+from sympy.matrices import Matrix, rot_axis3
+from sympy.utilities.iterables import is_sequence
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+class Curve(GeometrySet):
+ """A curve in space.
+
+ A curve is defined by parametric functions for the coordinates, a
+ parameter and the lower and upper bounds for the parameter value.
+
+ Parameters
+ ==========
+
+ function : list of functions
+ limits : 3-tuple
+ Function parameter and lower and upper bounds.
+
+ Attributes
+ ==========
+
+ functions
+ parameter
+ limits
+
+ Raises
+ ======
+
+ ValueError
+ When `functions` are specified incorrectly.
+ When `limits` are specified incorrectly.
+
+ Examples
+ ========
+
+ >>> from sympy import Curve, sin, cos, interpolate
+ >>> from sympy.abc import t, a
+ >>> C = Curve((sin(t), cos(t)), (t, 0, 2))
+ >>> C.functions
+ (sin(t), cos(t))
+ >>> C.limits
+ (t, 0, 2)
+ >>> C.parameter
+ t
+ >>> C = Curve((t, interpolate([1, 4, 9, 16], t)), (t, 0, 1)); C
+ Curve((t, t**2), (t, 0, 1))
+ >>> C.subs(t, 4)
+ Point2D(4, 16)
+ >>> C.arbitrary_point(a)
+ Point2D(a, a**2)
+
+ See Also
+ ========
+
+ sympy.core.function.Function
+ sympy.polys.polyfuncs.interpolate
+
+ """
+
+ def __new__(cls, function, limits):
+ if not is_sequence(function) or len(function) != 2:
+ raise ValueError("Function argument should be (x(t), y(t)) "
+ "but got %s" % str(function))
+ if not is_sequence(limits) or len(limits) != 3:
+ raise ValueError("Limit argument should be (t, tmin, tmax) "
+ "but got %s" % str(limits))
+
+ return GeometryEntity.__new__(cls, Tuple(*function), Tuple(*limits))
+
+ def __call__(self, f):
+ return self.subs(self.parameter, f)
+
+ def _eval_subs(self, old, new):
+ if old == self.parameter:
+ return Point(*[f.subs(old, new) for f in self.functions])
+
+ def _eval_evalf(self, prec=15, **options):
+ f, (t, a, b) = self.args
+ dps = prec_to_dps(prec)
+ f = tuple([i.evalf(n=dps, **options) for i in f])
+ a, b = [i.evalf(n=dps, **options) for i in (a, b)]
+ return self.func(f, (t, a, b))
+
+ def arbitrary_point(self, parameter='t'):
+ """A parameterized point on the curve.
+
+ Parameters
+ ==========
+
+ parameter : str or Symbol, optional
+ Default value is 't'.
+ The Curve's parameter is selected with None or self.parameter
+ otherwise the provided symbol is used.
+
+ Returns
+ =======
+
+ Point :
+ Returns a point in parametric form.
+
+ Raises
+ ======
+
+ ValueError
+ When `parameter` already appears in the functions.
+
+ Examples
+ ========
+
+ >>> from sympy import Curve, Symbol
+ >>> from sympy.abc import s
+ >>> C = Curve([2*s, s**2], (s, 0, 2))
+ >>> C.arbitrary_point()
+ Point2D(2*t, t**2)
+ >>> C.arbitrary_point(C.parameter)
+ Point2D(2*s, s**2)
+ >>> C.arbitrary_point(None)
+ Point2D(2*s, s**2)
+ >>> C.arbitrary_point(Symbol('a'))
+ Point2D(2*a, a**2)
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ """
+ if parameter is None:
+ return Point(*self.functions)
+
+ tnew = _symbol(parameter, self.parameter, real=True)
+ t = self.parameter
+ if (tnew.name != t.name and
+ tnew.name in (f.name for f in self.free_symbols)):
+ raise ValueError('Symbol %s already appears in object '
+ 'and cannot be used as a parameter.' % tnew.name)
+ return Point(*[w.subs(t, tnew) for w in self.functions])
+
+ @property
+ def free_symbols(self):
+ """Return a set of symbols other than the bound symbols used to
+ parametrically define the Curve.
+
+ Returns
+ =======
+
+ set :
+ Set of all non-parameterized symbols.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import t, a
+ >>> from sympy import Curve
+ >>> Curve((t, t**2), (t, 0, 2)).free_symbols
+ set()
+ >>> Curve((t, t**2), (t, a, 2)).free_symbols
+ {a}
+
+ """
+ free = set()
+ for a in self.functions + self.limits[1:]:
+ free |= a.free_symbols
+ free = free.difference({self.parameter})
+ return free
+
+ @property
+ def ambient_dimension(self):
+ """The dimension of the curve.
+
+ Returns
+ =======
+
+ int :
+ the dimension of curve.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import t
+ >>> from sympy import Curve
+ >>> C = Curve((t, t**2), (t, 0, 2))
+ >>> C.ambient_dimension
+ 2
+
+ """
+
+ return len(self.args[0])
+
+ @property
+ def functions(self):
+ """The functions specifying the curve.
+
+ Returns
+ =======
+
+ functions :
+ list of parameterized coordinate functions.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import t
+ >>> from sympy import Curve
+ >>> C = Curve((t, t**2), (t, 0, 2))
+ >>> C.functions
+ (t, t**2)
+
+ See Also
+ ========
+
+ parameter
+
+ """
+ return self.args[0]
+
+ @property
+ def limits(self):
+ """The limits for the curve.
+
+ Returns
+ =======
+
+ limits : tuple
+ Contains parameter and lower and upper limits.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import t
+ >>> from sympy import Curve
+ >>> C = Curve([t, t**3], (t, -2, 2))
+ >>> C.limits
+ (t, -2, 2)
+
+ See Also
+ ========
+
+ plot_interval
+
+ """
+ return self.args[1]
+
+ @property
+ def parameter(self):
+ """The curve function variable.
+
+ Returns
+ =======
+
+ Symbol :
+ returns a bound symbol.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import t
+ >>> from sympy import Curve
+ >>> C = Curve([t, t**2], (t, 0, 2))
+ >>> C.parameter
+ t
+
+ See Also
+ ========
+
+ functions
+
+ """
+ return self.args[1][0]
+
+ @property
+ def length(self):
+ """The curve length.
+
+ Examples
+ ========
+
+ >>> from sympy import Curve
+ >>> from sympy.abc import t
+ >>> Curve((t, t), (t, 0, 1)).length
+ sqrt(2)
+
+ """
+ integrand = sqrt(sum(diff(func, self.limits[0])**2 for func in self.functions))
+ return integrate(integrand, self.limits)
+
+ def plot_interval(self, parameter='t'):
+ """The plot interval for the default geometric plot of the curve.
+
+ Parameters
+ ==========
+
+ parameter : str or Symbol, optional
+ Default value is 't';
+ otherwise the provided symbol is used.
+
+ Returns
+ =======
+
+ List :
+ the plot interval as below:
+ [parameter, lower_bound, upper_bound]
+
+ Examples
+ ========
+
+ >>> from sympy import Curve, sin
+ >>> from sympy.abc import x, s
+ >>> Curve((x, sin(x)), (x, 1, 2)).plot_interval()
+ [t, 1, 2]
+ >>> Curve((x, sin(x)), (x, 1, 2)).plot_interval(s)
+ [s, 1, 2]
+
+ See Also
+ ========
+
+ limits : Returns limits of the parameter interval
+
+ """
+ t = _symbol(parameter, self.parameter, real=True)
+ return [t] + list(self.limits[1:])
+
+ def rotate(self, angle=0, pt=None):
+ """This function is used to rotate a curve along given point ``pt`` at given angle(in radian).
+
+ Parameters
+ ==========
+
+ angle :
+ the angle at which the curve will be rotated(in radian) in counterclockwise direction.
+ default value of angle is 0.
+
+ pt : Point
+ the point along which the curve will be rotated.
+ If no point given, the curve will be rotated around origin.
+
+ Returns
+ =======
+
+ Curve :
+ returns a curve rotated at given angle along given point.
+
+ Examples
+ ========
+
+ >>> from sympy import Curve, pi
+ >>> from sympy.abc import x
+ >>> Curve((x, x), (x, 0, 1)).rotate(pi/2)
+ Curve((-x, x), (x, 0, 1))
+
+ """
+ if pt:
+ pt = -Point(pt, dim=2)
+ else:
+ pt = Point(0,0)
+ rv = self.translate(*pt.args)
+ f = list(rv.functions)
+ f.append(0)
+ f = Matrix(1, 3, f)
+ f *= rot_axis3(angle)
+ rv = self.func(f[0, :2].tolist()[0], self.limits)
+ pt = -pt
+ return rv.translate(*pt.args)
+
+ def scale(self, x=1, y=1, pt=None):
+ """Override GeometryEntity.scale since Curve is not made up of Points.
+
+ Returns
+ =======
+
+ Curve :
+ returns scaled curve.
+
+ Examples
+ ========
+
+ >>> from sympy import Curve
+ >>> from sympy.abc import x
+ >>> Curve((x, x), (x, 0, 1)).scale(2)
+ Curve((2*x, x), (x, 0, 1))
+
+ """
+ if pt:
+ pt = Point(pt, dim=2)
+ return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+ fx, fy = self.functions
+ return self.func((fx*x, fy*y), self.limits)
+
+ def translate(self, x=0, y=0):
+ """Translate the Curve by (x, y).
+
+ Returns
+ =======
+
+ Curve :
+ returns a translated curve.
+
+ Examples
+ ========
+
+ >>> from sympy import Curve
+ >>> from sympy.abc import x
+ >>> Curve((x, x), (x, 0, 1)).translate(1, 2)
+ Curve((x + 1, x + 2), (x, 0, 1))
+
+ """
+ fx, fy = self.functions
+ return self.func((fx + x, fy + y), self.limits)
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/ellipse.py b/janus/lib/python3.10/site-packages/sympy/geometry/ellipse.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd4902e5f55d23c245d816afc98d462ef06630cb
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/geometry/ellipse.py
@@ -0,0 +1,1767 @@
+"""Elliptical geometrical entities.
+
+Contains
+* Ellipse
+* Circle
+
+"""
+
+from sympy.core.expr import Expr
+from sympy.core.relational import Eq
+from sympy.core import S, pi, sympify
+from sympy.core.evalf import N
+from sympy.core.parameters import global_parameters
+from sympy.core.logic import fuzzy_bool
+from sympy.core.numbers import Rational, oo
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy, uniquely_named_symbol, _symbol
+from sympy.simplify import simplify, trigsimp
+from sympy.functions.elementary.miscellaneous import sqrt, Max
+from sympy.functions.elementary.trigonometric import cos, sin
+from sympy.functions.special.elliptic_integrals import elliptic_e
+from .entity import GeometryEntity, GeometrySet
+from .exceptions import GeometryError
+from .line import Line, Segment, Ray2D, Segment2D, Line2D, LinearEntity3D
+from .point import Point, Point2D, Point3D
+from .util import idiff, find
+from sympy.polys import DomainError, Poly, PolynomialError
+from sympy.polys.polyutils import _not_a_coeff, _nsort
+from sympy.solvers import solve
+from sympy.solvers.solveset import linear_coeffs
+from sympy.utilities.misc import filldedent, func_name
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+import random
+
+x, y = [Dummy('ellipse_dummy', real=True) for i in range(2)]
+
+
+class Ellipse(GeometrySet):
+ """An elliptical GeometryEntity.
+
+ Parameters
+ ==========
+
+ center : Point, optional
+ Default value is Point(0, 0)
+ hradius : number or SymPy expression, optional
+ vradius : number or SymPy expression, optional
+ eccentricity : number or SymPy expression, optional
+ Two of `hradius`, `vradius` and `eccentricity` must be supplied to
+ create an Ellipse. The third is derived from the two supplied.
+
+ Attributes
+ ==========
+
+ center
+ hradius
+ vradius
+ area
+ circumference
+ eccentricity
+ periapsis
+ apoapsis
+ focus_distance
+ foci
+
+ Raises
+ ======
+
+ GeometryError
+ When `hradius`, `vradius` and `eccentricity` are incorrectly supplied
+ as parameters.
+ TypeError
+ When `center` is not a Point.
+
+ See Also
+ ========
+
+ Circle
+
+ Notes
+ -----
+ Constructed from a center and two radii, the first being the horizontal
+ radius (along the x-axis) and the second being the vertical radius (along
+ the y-axis).
+
+ When symbolic value for hradius and vradius are used, any calculation that
+ refers to the foci or the major or minor axis will assume that the ellipse
+ has its major radius on the x-axis. If this is not true then a manual
+ rotation is necessary.
+
+ Examples
+ ========
+
+ >>> from sympy import Ellipse, Point, Rational
+ >>> e1 = Ellipse(Point(0, 0), 5, 1)
+ >>> e1.hradius, e1.vradius
+ (5, 1)
+ >>> e2 = Ellipse(Point(3, 1), hradius=3, eccentricity=Rational(4, 5))
+ >>> e2
+ Ellipse(Point2D(3, 1), 3, 9/5)
+
+ """
+
+ def __contains__(self, o):
+ if isinstance(o, Point):
+ res = self.equation(x, y).subs({x: o.x, y: o.y})
+ return trigsimp(simplify(res)) is S.Zero
+ elif isinstance(o, Ellipse):
+ return self == o
+ return False
+
+ def __eq__(self, o):
+ """Is the other GeometryEntity the same as this ellipse?"""
+ return isinstance(o, Ellipse) and (self.center == o.center and
+ self.hradius == o.hradius and
+ self.vradius == o.vradius)
+
+ def __hash__(self):
+ return super().__hash__()
+
+ def __new__(
+ cls, center=None, hradius=None, vradius=None, eccentricity=None, **kwargs):
+
+ hradius = sympify(hradius)
+ vradius = sympify(vradius)
+
+ if center is None:
+ center = Point(0, 0)
+ else:
+ if len(center) != 2:
+ raise ValueError('The center of "{}" must be a two dimensional point'.format(cls))
+ center = Point(center, dim=2)
+
+ if len(list(filter(lambda x: x is not None, (hradius, vradius, eccentricity)))) != 2:
+ raise ValueError(filldedent('''
+ Exactly two arguments of "hradius", "vradius", and
+ "eccentricity" must not be None.'''))
+
+ if eccentricity is not None:
+ eccentricity = sympify(eccentricity)
+ if eccentricity.is_negative:
+ raise GeometryError("Eccentricity of ellipse/circle should lie between [0, 1)")
+ elif hradius is None:
+ hradius = vradius / sqrt(1 - eccentricity**2)
+ elif vradius is None:
+ vradius = hradius * sqrt(1 - eccentricity**2)
+
+ if hradius == vradius:
+ return Circle(center, hradius, **kwargs)
+
+ if S.Zero in (hradius, vradius):
+ return Segment(Point(center[0] - hradius, center[1] - vradius), Point(center[0] + hradius, center[1] + vradius))
+
+ if hradius.is_real is False or vradius.is_real is False:
+ raise GeometryError("Invalid value encountered when computing hradius / vradius.")
+
+ return GeometryEntity.__new__(cls, center, hradius, vradius, **kwargs)
+
+ def _svg(self, scale_factor=1., fill_color="#66cc99"):
+ """Returns SVG ellipse element for the Ellipse.
+
+ Parameters
+ ==========
+
+ scale_factor : float
+ Multiplication factor for the SVG stroke-width. Default is 1.
+ fill_color : str, optional
+ Hex string for fill color. Default is "#66cc99".
+ """
+
+ c = N(self.center)
+ h, v = N(self.hradius), N(self.vradius)
+ return (
+ ''
+ ).format(2. * scale_factor, fill_color, c.x, c.y, h, v)
+
+ @property
+ def ambient_dimension(self):
+ return 2
+
+ @property
+ def apoapsis(self):
+ """The apoapsis of the ellipse.
+
+ The greatest distance between the focus and the contour.
+
+ Returns
+ =======
+
+ apoapsis : number
+
+ See Also
+ ========
+
+ periapsis : Returns shortest distance between foci and contour
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.apoapsis
+ 2*sqrt(2) + 3
+
+ """
+ return self.major * (1 + self.eccentricity)
+
+ def arbitrary_point(self, parameter='t'):
+ """A parameterized point on the ellipse.
+
+ Parameters
+ ==========
+
+ parameter : str, optional
+ Default value is 't'.
+
+ Returns
+ =======
+
+ arbitrary_point : Point
+
+ Raises
+ ======
+
+ ValueError
+ When `parameter` already appears in the functions.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> e1 = Ellipse(Point(0, 0), 3, 2)
+ >>> e1.arbitrary_point()
+ Point2D(3*cos(t), 2*sin(t))
+
+ """
+ t = _symbol(parameter, real=True)
+ if t.name in (f.name for f in self.free_symbols):
+ raise ValueError(filldedent('Symbol %s already appears in object '
+ 'and cannot be used as a parameter.' % t.name))
+ return Point(self.center.x + self.hradius*cos(t),
+ self.center.y + self.vradius*sin(t))
+
+ @property
+ def area(self):
+ """The area of the ellipse.
+
+ Returns
+ =======
+
+ area : number
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.area
+ 3*pi
+
+ """
+ return simplify(S.Pi * self.hradius * self.vradius)
+
+ @property
+ def bounds(self):
+ """Return a tuple (xmin, ymin, xmax, ymax) representing the bounding
+ rectangle for the geometric figure.
+
+ """
+
+ h, v = self.hradius, self.vradius
+ return (self.center.x - h, self.center.y - v, self.center.x + h, self.center.y + v)
+
+ @property
+ def center(self):
+ """The center of the ellipse.
+
+ Returns
+ =======
+
+ center : number
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.center
+ Point2D(0, 0)
+
+ """
+ return self.args[0]
+
+ @property
+ def circumference(self):
+ """The circumference of the ellipse.
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.circumference
+ 12*elliptic_e(8/9)
+
+ """
+ if self.eccentricity == 1:
+ # degenerate
+ return 4*self.major
+ elif self.eccentricity == 0:
+ # circle
+ return 2*pi*self.hradius
+ else:
+ return 4*self.major*elliptic_e(self.eccentricity**2)
+
+ @property
+ def eccentricity(self):
+ """The eccentricity of the ellipse.
+
+ Returns
+ =======
+
+ eccentricity : number
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse, sqrt
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, sqrt(2))
+ >>> e1.eccentricity
+ sqrt(7)/3
+
+ """
+ return self.focus_distance / self.major
+
+ def encloses_point(self, p):
+ """
+ Return True if p is enclosed by (is inside of) self.
+
+ Notes
+ -----
+ Being on the border of self is considered False.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ encloses_point : True, False or None
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Ellipse, S
+ >>> from sympy.abc import t
+ >>> e = Ellipse((0, 0), 3, 2)
+ >>> e.encloses_point((0, 0))
+ True
+ >>> e.encloses_point(e.arbitrary_point(t).subs(t, S.Half))
+ False
+ >>> e.encloses_point((4, 0))
+ False
+
+ """
+ p = Point(p, dim=2)
+ if p in self:
+ return False
+
+ if len(self.foci) == 2:
+ # if the combined distance from the foci to p (h1 + h2) is less
+ # than the combined distance from the foci to the minor axis
+ # (which is the same as the major axis length) then p is inside
+ # the ellipse
+ h1, h2 = [f.distance(p) for f in self.foci]
+ test = 2*self.major - (h1 + h2)
+ else:
+ test = self.radius - self.center.distance(p)
+
+ return fuzzy_bool(test.is_positive)
+
+ def equation(self, x='x', y='y', _slope=None):
+ """
+ Returns the equation of an ellipse aligned with the x and y axes;
+ when slope is given, the equation returned corresponds to an ellipse
+ with a major axis having that slope.
+
+ Parameters
+ ==========
+
+ x : str, optional
+ Label for the x-axis. Default value is 'x'.
+ y : str, optional
+ Label for the y-axis. Default value is 'y'.
+ _slope : Expr, optional
+ The slope of the major axis. Ignored when 'None'.
+
+ Returns
+ =======
+
+ equation : SymPy expression
+
+ See Also
+ ========
+
+ arbitrary_point : Returns parameterized point on ellipse
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse, pi
+ >>> from sympy.abc import x, y
+ >>> e1 = Ellipse(Point(1, 0), 3, 2)
+ >>> eq1 = e1.equation(x, y); eq1
+ y**2/4 + (x/3 - 1/3)**2 - 1
+ >>> eq2 = e1.equation(x, y, _slope=1); eq2
+ (-x + y + 1)**2/8 + (x + y - 1)**2/18 - 1
+
+ A point on e1 satisfies eq1. Let's use one on the x-axis:
+
+ >>> p1 = e1.center + Point(e1.major, 0)
+ >>> assert eq1.subs(x, p1.x).subs(y, p1.y) == 0
+
+ When rotated the same as the rotated ellipse, about the center
+ point of the ellipse, it will satisfy the rotated ellipse's
+ equation, too:
+
+ >>> r1 = p1.rotate(pi/4, e1.center)
+ >>> assert eq2.subs(x, r1.x).subs(y, r1.y) == 0
+
+ References
+ ==========
+
+ .. [1] https://math.stackexchange.com/questions/108270/what-is-the-equation-of-an-ellipse-that-is-not-aligned-with-the-axis
+ .. [2] https://en.wikipedia.org/wiki/Ellipse#Shifted_ellipse
+
+ """
+
+ x = _symbol(x, real=True)
+ y = _symbol(y, real=True)
+
+ dx = x - self.center.x
+ dy = y - self.center.y
+
+ if _slope is not None:
+ L = (dy - _slope*dx)**2
+ l = (_slope*dy + dx)**2
+ h = 1 + _slope**2
+ b = h*self.major**2
+ a = h*self.minor**2
+ return l/b + L/a - 1
+
+ else:
+ t1 = (dx/self.hradius)**2
+ t2 = (dy/self.vradius)**2
+ return t1 + t2 - 1
+
+ def evolute(self, x='x', y='y'):
+ """The equation of evolute of the ellipse.
+
+ Parameters
+ ==========
+
+ x : str, optional
+ Label for the x-axis. Default value is 'x'.
+ y : str, optional
+ Label for the y-axis. Default value is 'y'.
+
+ Returns
+ =======
+
+ equation : SymPy expression
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> e1 = Ellipse(Point(1, 0), 3, 2)
+ >>> e1.evolute()
+ 2**(2/3)*y**(2/3) + (3*x - 3)**(2/3) - 5**(2/3)
+ """
+ if len(self.args) != 3:
+ raise NotImplementedError('Evolute of arbitrary Ellipse is not supported.')
+ x = _symbol(x, real=True)
+ y = _symbol(y, real=True)
+ t1 = (self.hradius*(x - self.center.x))**Rational(2, 3)
+ t2 = (self.vradius*(y - self.center.y))**Rational(2, 3)
+ return t1 + t2 - (self.hradius**2 - self.vradius**2)**Rational(2, 3)
+
+ @property
+ def foci(self):
+ """The foci of the ellipse.
+
+ Notes
+ -----
+ The foci can only be calculated if the major/minor axes are known.
+
+ Raises
+ ======
+
+ ValueError
+ When the major and minor axis cannot be determined.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+ focus_distance : Returns the distance between focus and center
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.foci
+ (Point2D(-2*sqrt(2), 0), Point2D(2*sqrt(2), 0))
+
+ """
+ c = self.center
+ hr, vr = self.hradius, self.vradius
+ if hr == vr:
+ return (c, c)
+
+ # calculate focus distance manually, since focus_distance calls this
+ # routine
+ fd = sqrt(self.major**2 - self.minor**2)
+ if hr == self.minor:
+ # foci on the y-axis
+ return (c + Point(0, -fd), c + Point(0, fd))
+ elif hr == self.major:
+ # foci on the x-axis
+ return (c + Point(-fd, 0), c + Point(fd, 0))
+
+ @property
+ def focus_distance(self):
+ """The focal distance of the ellipse.
+
+ The distance between the center and one focus.
+
+ Returns
+ =======
+
+ focus_distance : number
+
+ See Also
+ ========
+
+ foci
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.focus_distance
+ 2*sqrt(2)
+
+ """
+ return Point.distance(self.center, self.foci[0])
+
+ @property
+ def hradius(self):
+ """The horizontal radius of the ellipse.
+
+ Returns
+ =======
+
+ hradius : number
+
+ See Also
+ ========
+
+ vradius, major, minor
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.hradius
+ 3
+
+ """
+ return self.args[1]
+
+ def intersection(self, o):
+ """The intersection of this ellipse and another geometrical entity
+ `o`.
+
+ Parameters
+ ==========
+
+ o : GeometryEntity
+
+ Returns
+ =======
+
+ intersection : list of GeometryEntity objects
+
+ Notes
+ -----
+ Currently supports intersections with Point, Line, Segment, Ray,
+ Circle and Ellipse types.
+
+ See Also
+ ========
+
+ sympy.geometry.entity.GeometryEntity
+
+ Examples
+ ========
+
+ >>> from sympy import Ellipse, Point, Line
+ >>> e = Ellipse(Point(0, 0), 5, 7)
+ >>> e.intersection(Point(0, 0))
+ []
+ >>> e.intersection(Point(5, 0))
+ [Point2D(5, 0)]
+ >>> e.intersection(Line(Point(0,0), Point(0, 1)))
+ [Point2D(0, -7), Point2D(0, 7)]
+ >>> e.intersection(Line(Point(5,0), Point(5, 1)))
+ [Point2D(5, 0)]
+ >>> e.intersection(Line(Point(6,0), Point(6, 1)))
+ []
+ >>> e = Ellipse(Point(-1, 0), 4, 3)
+ >>> e.intersection(Ellipse(Point(1, 0), 4, 3))
+ [Point2D(0, -3*sqrt(15)/4), Point2D(0, 3*sqrt(15)/4)]
+ >>> e.intersection(Ellipse(Point(5, 0), 4, 3))
+ [Point2D(2, -3*sqrt(7)/4), Point2D(2, 3*sqrt(7)/4)]
+ >>> e.intersection(Ellipse(Point(100500, 0), 4, 3))
+ []
+ >>> e.intersection(Ellipse(Point(0, 0), 3, 4))
+ [Point2D(3, 0), Point2D(-363/175, -48*sqrt(111)/175), Point2D(-363/175, 48*sqrt(111)/175)]
+ >>> e.intersection(Ellipse(Point(-1, 0), 3, 4))
+ [Point2D(-17/5, -12/5), Point2D(-17/5, 12/5), Point2D(7/5, -12/5), Point2D(7/5, 12/5)]
+ """
+ # TODO: Replace solve with nonlinsolve, when nonlinsolve will be able to solve in real domain
+
+ if isinstance(o, Point):
+ if o in self:
+ return [o]
+ else:
+ return []
+
+ elif isinstance(o, (Segment2D, Ray2D)):
+ ellipse_equation = self.equation(x, y)
+ result = solve([ellipse_equation, Line(
+ o.points[0], o.points[1]).equation(x, y)], [x, y],
+ set=True)[1]
+ return list(ordered([Point(i) for i in result if i in o]))
+
+ elif isinstance(o, Polygon):
+ return o.intersection(self)
+
+ elif isinstance(o, (Ellipse, Line2D)):
+ if o == self:
+ return self
+ else:
+ ellipse_equation = self.equation(x, y)
+ return list(ordered([Point(i) for i in solve(
+ [ellipse_equation, o.equation(x, y)], [x, y],
+ set=True)[1]]))
+ elif isinstance(o, LinearEntity3D):
+ raise TypeError('Entity must be two dimensional, not three dimensional')
+ else:
+ raise TypeError('Intersection not handled for %s' % func_name(o))
+
+ def is_tangent(self, o):
+ """Is `o` tangent to the ellipse?
+
+ Parameters
+ ==========
+
+ o : GeometryEntity
+ An Ellipse, LinearEntity or Polygon
+
+ Raises
+ ======
+
+ NotImplementedError
+ When the wrong type of argument is supplied.
+
+ Returns
+ =======
+
+ is_tangent: boolean
+ True if o is tangent to the ellipse, False otherwise.
+
+ See Also
+ ========
+
+ tangent_lines
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse, Line
+ >>> p0, p1, p2 = Point(0, 0), Point(3, 0), Point(3, 3)
+ >>> e1 = Ellipse(p0, 3, 2)
+ >>> l1 = Line(p1, p2)
+ >>> e1.is_tangent(l1)
+ True
+
+ """
+ if isinstance(o, Point2D):
+ return False
+ elif isinstance(o, Ellipse):
+ intersect = self.intersection(o)
+ if isinstance(intersect, Ellipse):
+ return True
+ elif intersect:
+ return all((self.tangent_lines(i)[0]).equals(o.tangent_lines(i)[0]) for i in intersect)
+ else:
+ return False
+ elif isinstance(o, Line2D):
+ hit = self.intersection(o)
+ if not hit:
+ return False
+ if len(hit) == 1:
+ return True
+ # might return None if it can't decide
+ return hit[0].equals(hit[1])
+ elif isinstance(o, (Segment2D, Ray2D)):
+ intersect = self.intersection(o)
+ if len(intersect) == 1:
+ return o in self.tangent_lines(intersect[0])[0]
+ else:
+ return False
+ elif isinstance(o, Polygon):
+ return all(self.is_tangent(s) for s in o.sides)
+ elif isinstance(o, (LinearEntity3D, Point3D)):
+ raise TypeError('Entity must be two dimensional, not three dimensional')
+ else:
+ raise TypeError('Is_tangent not handled for %s' % func_name(o))
+
+ @property
+ def major(self):
+ """Longer axis of the ellipse (if it can be determined) else hradius.
+
+ Returns
+ =======
+
+ major : number or expression
+
+ See Also
+ ========
+
+ hradius, vradius, minor
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse, Symbol
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.major
+ 3
+
+ >>> a = Symbol('a')
+ >>> b = Symbol('b')
+ >>> Ellipse(p1, a, b).major
+ a
+ >>> Ellipse(p1, b, a).major
+ b
+
+ >>> m = Symbol('m')
+ >>> M = m + 1
+ >>> Ellipse(p1, m, M).major
+ m + 1
+
+ """
+ ab = self.args[1:3]
+ if len(ab) == 1:
+ return ab[0]
+ a, b = ab
+ o = b - a < 0
+ if o == True:
+ return a
+ elif o == False:
+ return b
+ return self.hradius
+
+ @property
+ def minor(self):
+ """Shorter axis of the ellipse (if it can be determined) else vradius.
+
+ Returns
+ =======
+
+ minor : number or expression
+
+ See Also
+ ========
+
+ hradius, vradius, major
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse, Symbol
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.minor
+ 1
+
+ >>> a = Symbol('a')
+ >>> b = Symbol('b')
+ >>> Ellipse(p1, a, b).minor
+ b
+ >>> Ellipse(p1, b, a).minor
+ a
+
+ >>> m = Symbol('m')
+ >>> M = m + 1
+ >>> Ellipse(p1, m, M).minor
+ m
+
+ """
+ ab = self.args[1:3]
+ if len(ab) == 1:
+ return ab[0]
+ a, b = ab
+ o = a - b < 0
+ if o == True:
+ return a
+ elif o == False:
+ return b
+ return self.vradius
+
+ def normal_lines(self, p, prec=None):
+ """Normal lines between `p` and the ellipse.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ normal_lines : list with 1, 2 or 4 Lines
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> e = Ellipse((0, 0), 2, 3)
+ >>> c = e.center
+ >>> e.normal_lines(c + Point(1, 0))
+ [Line2D(Point2D(0, 0), Point2D(1, 0))]
+ >>> e.normal_lines(c)
+ [Line2D(Point2D(0, 0), Point2D(0, 1)), Line2D(Point2D(0, 0), Point2D(1, 0))]
+
+ Off-axis points require the solution of a quartic equation. This
+ often leads to very large expressions that may be of little practical
+ use. An approximate solution of `prec` digits can be obtained by
+ passing in the desired value:
+
+ >>> e.normal_lines((3, 3), prec=2)
+ [Line2D(Point2D(-0.81, -2.7), Point2D(0.19, -1.2)),
+ Line2D(Point2D(1.5, -2.0), Point2D(2.5, -2.7))]
+
+ Whereas the above solution has an operation count of 12, the exact
+ solution has an operation count of 2020.
+ """
+ p = Point(p, dim=2)
+
+ # XXX change True to something like self.angle == 0 if the arbitrarily
+ # rotated ellipse is introduced.
+ # https://github.com/sympy/sympy/issues/2815)
+ if True:
+ rv = []
+ if p.x == self.center.x:
+ rv.append(Line(self.center, slope=oo))
+ if p.y == self.center.y:
+ rv.append(Line(self.center, slope=0))
+ if rv:
+ # at these special orientations of p either 1 or 2 normals
+ # exist and we are done
+ return rv
+
+ # find the 4 normal points and construct lines through them with
+ # the corresponding slope
+ eq = self.equation(x, y)
+ dydx = idiff(eq, y, x)
+ norm = -1/dydx
+ slope = Line(p, (x, y)).slope
+ seq = slope - norm
+
+ # TODO: Replace solve with solveset, when this line is tested
+ yis = solve(seq, y)[0]
+ xeq = eq.subs(y, yis).as_numer_denom()[0].expand()
+ if len(xeq.free_symbols) == 1:
+ try:
+ # this is so much faster, it's worth a try
+ xsol = Poly(xeq, x).real_roots()
+ except (DomainError, PolynomialError, NotImplementedError):
+ # TODO: Replace solve with solveset, when these lines are tested
+ xsol = _nsort(solve(xeq, x), separated=True)[0]
+ points = [Point(i, solve(eq.subs(x, i), y)[0]) for i in xsol]
+ else:
+ raise NotImplementedError(
+ 'intersections for the general ellipse are not supported')
+ slopes = [norm.subs(zip((x, y), pt.args)) for pt in points]
+ if prec is not None:
+ points = [pt.n(prec) for pt in points]
+ slopes = [i if _not_a_coeff(i) else i.n(prec) for i in slopes]
+ return [Line(pt, slope=s) for pt, s in zip(points, slopes)]
+
+ @property
+ def periapsis(self):
+ """The periapsis of the ellipse.
+
+ The shortest distance between the focus and the contour.
+
+ Returns
+ =======
+
+ periapsis : number
+
+ See Also
+ ========
+
+ apoapsis : Returns greatest distance between focus and contour
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.periapsis
+ 3 - 2*sqrt(2)
+
+ """
+ return self.major * (1 - self.eccentricity)
+
+ @property
+ def semilatus_rectum(self):
+ """
+ Calculates the semi-latus rectum of the Ellipse.
+
+ Semi-latus rectum is defined as one half of the chord through a
+ focus parallel to the conic section directrix of a conic section.
+
+ Returns
+ =======
+
+ semilatus_rectum : number
+
+ See Also
+ ========
+
+ apoapsis : Returns greatest distance between focus and contour
+
+ periapsis : The shortest distance between the focus and the contour
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.semilatus_rectum
+ 1/3
+
+ References
+ ==========
+
+ .. [1] https://mathworld.wolfram.com/SemilatusRectum.html
+ .. [2] https://en.wikipedia.org/wiki/Ellipse#Semi-latus_rectum
+
+ """
+ return self.major * (1 - self.eccentricity ** 2)
+
+ def auxiliary_circle(self):
+ """Returns a Circle whose diameter is the major axis of the ellipse.
+
+ Examples
+ ========
+
+ >>> from sympy import Ellipse, Point, symbols
+ >>> c = Point(1, 2)
+ >>> Ellipse(c, 8, 7).auxiliary_circle()
+ Circle(Point2D(1, 2), 8)
+ >>> a, b = symbols('a b')
+ >>> Ellipse(c, a, b).auxiliary_circle()
+ Circle(Point2D(1, 2), Max(a, b))
+ """
+ return Circle(self.center, Max(self.hradius, self.vradius))
+
+ def director_circle(self):
+ """
+ Returns a Circle consisting of all points where two perpendicular
+ tangent lines to the ellipse cross each other.
+
+ Returns
+ =======
+
+ Circle
+ A director circle returned as a geometric object.
+
+ Examples
+ ========
+
+ >>> from sympy import Ellipse, Point, symbols
+ >>> c = Point(3,8)
+ >>> Ellipse(c, 7, 9).director_circle()
+ Circle(Point2D(3, 8), sqrt(130))
+ >>> a, b = symbols('a b')
+ >>> Ellipse(c, a, b).director_circle()
+ Circle(Point2D(3, 8), sqrt(a**2 + b**2))
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Director_circle
+
+ """
+ return Circle(self.center, sqrt(self.hradius**2 + self.vradius**2))
+
+ def plot_interval(self, parameter='t'):
+ """The plot interval for the default geometric plot of the Ellipse.
+
+ Parameters
+ ==========
+
+ parameter : str, optional
+ Default value is 't'.
+
+ Returns
+ =======
+
+ plot_interval : list
+ [parameter, lower_bound, upper_bound]
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> e1 = Ellipse(Point(0, 0), 3, 2)
+ >>> e1.plot_interval()
+ [t, -pi, pi]
+
+ """
+ t = _symbol(parameter, real=True)
+ return [t, -S.Pi, S.Pi]
+
+ def random_point(self, seed=None):
+ """A random point on the ellipse.
+
+ Returns
+ =======
+
+ point : Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> e1 = Ellipse(Point(0, 0), 3, 2)
+ >>> e1.random_point() # gives some random point
+ Point2D(...)
+ >>> p1 = e1.random_point(seed=0); p1.n(2)
+ Point2D(2.1, 1.4)
+
+ Notes
+ =====
+
+ When creating a random point, one may simply replace the
+ parameter with a random number. When doing so, however, the
+ random number should be made a Rational or else the point
+ may not test as being in the ellipse:
+
+ >>> from sympy.abc import t
+ >>> from sympy import Rational
+ >>> arb = e1.arbitrary_point(t); arb
+ Point2D(3*cos(t), 2*sin(t))
+ >>> arb.subs(t, .1) in e1
+ False
+ >>> arb.subs(t, Rational(.1)) in e1
+ True
+ >>> arb.subs(t, Rational('.1')) in e1
+ True
+
+ See Also
+ ========
+ sympy.geometry.point.Point
+ arbitrary_point : Returns parameterized point on ellipse
+ """
+ t = _symbol('t', real=True)
+ x, y = self.arbitrary_point(t).args
+ # get a random value in [-1, 1) corresponding to cos(t)
+ # and confirm that it will test as being in the ellipse
+ if seed is not None:
+ rng = random.Random(seed)
+ else:
+ rng = random
+ # simplify this now or else the Float will turn s into a Float
+ r = Rational(rng.random())
+ c = 2*r - 1
+ s = sqrt(1 - c**2)
+ return Point(x.subs(cos(t), c), y.subs(sin(t), s))
+
+ def reflect(self, line):
+ """Override GeometryEntity.reflect since the radius
+ is not a GeometryEntity.
+
+ Examples
+ ========
+
+ >>> from sympy import Circle, Line
+ >>> Circle((0, 1), 1).reflect(Line((0, 0), (1, 1)))
+ Circle(Point2D(1, 0), -1)
+ >>> from sympy import Ellipse, Line, Point
+ >>> Ellipse(Point(3, 4), 1, 3).reflect(Line(Point(0, -4), Point(5, 0)))
+ Traceback (most recent call last):
+ ...
+ NotImplementedError:
+ General Ellipse is not supported but the equation of the reflected
+ Ellipse is given by the zeros of: f(x, y) = (9*x/41 + 40*y/41 +
+ 37/41)**2 + (40*x/123 - 3*y/41 - 364/123)**2 - 1
+
+ Notes
+ =====
+
+ Until the general ellipse (with no axis parallel to the x-axis) is
+ supported a NotImplemented error is raised and the equation whose
+ zeros define the rotated ellipse is given.
+
+ """
+
+ if line.slope in (0, oo):
+ c = self.center
+ c = c.reflect(line)
+ return self.func(c, -self.hradius, self.vradius)
+ else:
+ x, y = [uniquely_named_symbol(
+ name, (self, line), modify=lambda s: '_' + s, real=True)
+ for name in 'xy']
+ expr = self.equation(x, y)
+ p = Point(x, y).reflect(line)
+ result = expr.subs(zip((x, y), p.args
+ ), simultaneous=True)
+ raise NotImplementedError(filldedent(
+ 'General Ellipse is not supported but the equation '
+ 'of the reflected Ellipse is given by the zeros of: ' +
+ "f(%s, %s) = %s" % (str(x), str(y), str(result))))
+
+ def rotate(self, angle=0, pt=None):
+ """Rotate ``angle`` radians counterclockwise about Point ``pt``.
+
+ Note: since the general ellipse is not supported, only rotations that
+ are integer multiples of pi/2 are allowed.
+
+ Examples
+ ========
+
+ >>> from sympy import Ellipse, pi
+ >>> Ellipse((1, 0), 2, 1).rotate(pi/2)
+ Ellipse(Point2D(0, 1), 1, 2)
+ >>> Ellipse((1, 0), 2, 1).rotate(pi)
+ Ellipse(Point2D(-1, 0), 2, 1)
+ """
+ if self.hradius == self.vradius:
+ return self.func(self.center.rotate(angle, pt), self.hradius)
+ if (angle/S.Pi).is_integer:
+ return super().rotate(angle, pt)
+ if (2*angle/S.Pi).is_integer:
+ return self.func(self.center.rotate(angle, pt), self.vradius, self.hradius)
+ # XXX see https://github.com/sympy/sympy/issues/2815 for general ellipes
+ raise NotImplementedError('Only rotations of pi/2 are currently supported for Ellipse.')
+
+ def scale(self, x=1, y=1, pt=None):
+ """Override GeometryEntity.scale since it is the major and minor
+ axes which must be scaled and they are not GeometryEntities.
+
+ Examples
+ ========
+
+ >>> from sympy import Ellipse
+ >>> Ellipse((0, 0), 2, 1).scale(2, 4)
+ Circle(Point2D(0, 0), 4)
+ >>> Ellipse((0, 0), 2, 1).scale(2)
+ Ellipse(Point2D(0, 0), 4, 1)
+ """
+ c = self.center
+ if pt:
+ pt = Point(pt, dim=2)
+ return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+ h = self.hradius
+ v = self.vradius
+ return self.func(c.scale(x, y), hradius=h*x, vradius=v*y)
+
+ def tangent_lines(self, p):
+ """Tangent lines between `p` and the ellipse.
+
+ If `p` is on the ellipse, returns the tangent line through point `p`.
+ Otherwise, returns the tangent line(s) from `p` to the ellipse, or
+ None if no tangent line is possible (e.g., `p` inside ellipse).
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ tangent_lines : list with 1 or 2 Lines
+
+ Raises
+ ======
+
+ NotImplementedError
+ Can only find tangent lines for a point, `p`, on the ellipse.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, sympy.geometry.line.Line
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> e1 = Ellipse(Point(0, 0), 3, 2)
+ >>> e1.tangent_lines(Point(3, 0))
+ [Line2D(Point2D(3, 0), Point2D(3, -12))]
+
+ """
+ p = Point(p, dim=2)
+ if self.encloses_point(p):
+ return []
+
+ if p in self:
+ delta = self.center - p
+ rise = (self.vradius**2)*delta.x
+ run = -(self.hradius**2)*delta.y
+ p2 = Point(simplify(p.x + run),
+ simplify(p.y + rise))
+ return [Line(p, p2)]
+ else:
+ if len(self.foci) == 2:
+ f1, f2 = self.foci
+ maj = self.hradius
+ test = (2*maj -
+ Point.distance(f1, p) -
+ Point.distance(f2, p))
+ else:
+ test = self.radius - Point.distance(self.center, p)
+ if test.is_number and test.is_positive:
+ return []
+ # else p is outside the ellipse or we can't tell. In case of the
+ # latter, the solutions returned will only be valid if
+ # the point is not inside the ellipse; if it is, nan will result.
+ eq = self.equation(x, y)
+ dydx = idiff(eq, y, x)
+ slope = Line(p, Point(x, y)).slope
+
+ # TODO: Replace solve with solveset, when this line is tested
+ tangent_points = solve([slope - dydx, eq], [x, y])
+
+ # handle horizontal and vertical tangent lines
+ if len(tangent_points) == 1:
+ if tangent_points[0][
+ 0] == p.x or tangent_points[0][1] == p.y:
+ return [Line(p, p + Point(1, 0)), Line(p, p + Point(0, 1))]
+ else:
+ return [Line(p, p + Point(0, 1)), Line(p, tangent_points[0])]
+
+ # others
+ return [Line(p, tangent_points[0]), Line(p, tangent_points[1])]
+
+ @property
+ def vradius(self):
+ """The vertical radius of the ellipse.
+
+ Returns
+ =======
+
+ vradius : number
+
+ See Also
+ ========
+
+ hradius, major, minor
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.vradius
+ 1
+
+ """
+ return self.args[2]
+
+
+ def second_moment_of_area(self, point=None):
+ """Returns the second moment and product moment area of an ellipse.
+
+ Parameters
+ ==========
+
+ point : Point, two-tuple of sympifiable objects, or None(default=None)
+ point is the point about which second moment of area is to be found.
+ If "point=None" it will be calculated about the axis passing through the
+ centroid of the ellipse.
+
+ Returns
+ =======
+
+ I_xx, I_yy, I_xy : number or SymPy expression
+ I_xx, I_yy are second moment of area of an ellise.
+ I_xy is product moment of area of an ellipse.
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ellipse
+ >>> p1 = Point(0, 0)
+ >>> e1 = Ellipse(p1, 3, 1)
+ >>> e1.second_moment_of_area()
+ (3*pi/4, 27*pi/4, 0)
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/List_of_second_moments_of_area
+
+ """
+
+ I_xx = (S.Pi*(self.hradius)*(self.vradius**3))/4
+ I_yy = (S.Pi*(self.hradius**3)*(self.vradius))/4
+ I_xy = 0
+
+ if point is None:
+ return I_xx, I_yy, I_xy
+
+ # parallel axis theorem
+ I_xx = I_xx + self.area*((point[1] - self.center.y)**2)
+ I_yy = I_yy + self.area*((point[0] - self.center.x)**2)
+ I_xy = I_xy + self.area*(point[0] - self.center.x)*(point[1] - self.center.y)
+
+ return I_xx, I_yy, I_xy
+
+
+ def polar_second_moment_of_area(self):
+ """Returns the polar second moment of area of an Ellipse
+
+ It is a constituent of the second moment of area, linked through
+ the perpendicular axis theorem. While the planar second moment of
+ area describes an object's resistance to deflection (bending) when
+ subjected to a force applied to a plane parallel to the central
+ axis, the polar second moment of area describes an object's
+ resistance to deflection when subjected to a moment applied in a
+ plane perpendicular to the object's central axis (i.e. parallel to
+ the cross-section)
+
+ Examples
+ ========
+
+ >>> from sympy import symbols, Circle, Ellipse
+ >>> c = Circle((5, 5), 4)
+ >>> c.polar_second_moment_of_area()
+ 128*pi
+ >>> a, b = symbols('a, b')
+ >>> e = Ellipse((0, 0), a, b)
+ >>> e.polar_second_moment_of_area()
+ pi*a**3*b/4 + pi*a*b**3/4
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Polar_moment_of_inertia
+
+ """
+ second_moment = self.second_moment_of_area()
+ return second_moment[0] + second_moment[1]
+
+
+ def section_modulus(self, point=None):
+ """Returns a tuple with the section modulus of an ellipse
+
+ Section modulus is a geometric property of an ellipse defined as the
+ ratio of second moment of area to the distance of the extreme end of
+ the ellipse from the centroidal axis.
+
+ Parameters
+ ==========
+
+ point : Point, two-tuple of sympifyable objects, or None(default=None)
+ point is the point at which section modulus is to be found.
+ If "point=None" section modulus will be calculated for the
+ point farthest from the centroidal axis of the ellipse.
+
+ Returns
+ =======
+
+ S_x, S_y: numbers or SymPy expressions
+ S_x is the section modulus with respect to the x-axis
+ S_y is the section modulus with respect to the y-axis
+ A negative sign indicates that the section modulus is
+ determined for a point below the centroidal axis.
+
+ Examples
+ ========
+
+ >>> from sympy import Symbol, Ellipse, Circle, Point2D
+ >>> d = Symbol('d', positive=True)
+ >>> c = Circle((0, 0), d/2)
+ >>> c.section_modulus()
+ (pi*d**3/32, pi*d**3/32)
+ >>> e = Ellipse(Point2D(0, 0), 2, 4)
+ >>> e.section_modulus()
+ (8*pi, 4*pi)
+ >>> e.section_modulus((2, 2))
+ (16*pi, 4*pi)
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Section_modulus
+
+ """
+ x_c, y_c = self.center
+ if point is None:
+ # taking x and y as maximum distances from centroid
+ x_min, y_min, x_max, y_max = self.bounds
+ y = max(y_c - y_min, y_max - y_c)
+ x = max(x_c - x_min, x_max - x_c)
+ else:
+ # taking x and y as distances of the given point from the center
+ point = Point2D(point)
+ y = point.y - y_c
+ x = point.x - x_c
+
+ second_moment = self.second_moment_of_area()
+ S_x = second_moment[0]/y
+ S_y = second_moment[1]/x
+
+ return S_x, S_y
+
+
+class Circle(Ellipse):
+ """A circle in space.
+
+ Constructed simply from a center and a radius, from three
+ non-collinear points, or the equation of a circle.
+
+ Parameters
+ ==========
+
+ center : Point
+ radius : number or SymPy expression
+ points : sequence of three Points
+ equation : equation of a circle
+
+ Attributes
+ ==========
+
+ radius (synonymous with hradius, vradius, major and minor)
+ circumference
+ equation
+
+ Raises
+ ======
+
+ GeometryError
+ When the given equation is not that of a circle.
+ When trying to construct circle from incorrect parameters.
+
+ See Also
+ ========
+
+ Ellipse, sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Circle, Eq
+ >>> from sympy.abc import x, y, a, b
+
+ A circle constructed from a center and radius:
+
+ >>> c1 = Circle(Point(0, 0), 5)
+ >>> c1.hradius, c1.vradius, c1.radius
+ (5, 5, 5)
+
+ A circle constructed from three points:
+
+ >>> c2 = Circle(Point(0, 0), Point(1, 1), Point(1, 0))
+ >>> c2.hradius, c2.vradius, c2.radius, c2.center
+ (sqrt(2)/2, sqrt(2)/2, sqrt(2)/2, Point2D(1/2, 1/2))
+
+ A circle can be constructed from an equation in the form
+ `a*x**2 + by**2 + gx + hy + c = 0`, too:
+
+ >>> Circle(x**2 + y**2 - 25)
+ Circle(Point2D(0, 0), 5)
+
+ If the variables corresponding to x and y are named something
+ else, their name or symbol can be supplied:
+
+ >>> Circle(Eq(a**2 + b**2, 25), x='a', y=b)
+ Circle(Point2D(0, 0), 5)
+ """
+
+ def __new__(cls, *args, **kwargs):
+ evaluate = kwargs.get('evaluate', global_parameters.evaluate)
+ if len(args) == 1 and isinstance(args[0], (Expr, Eq)):
+ x = kwargs.get('x', 'x')
+ y = kwargs.get('y', 'y')
+ equation = args[0].expand()
+ if isinstance(equation, Eq):
+ equation = equation.lhs - equation.rhs
+ x = find(x, equation)
+ y = find(y, equation)
+
+ try:
+ a, b, c, d, e = linear_coeffs(equation, x**2, y**2, x, y)
+ except ValueError:
+ raise GeometryError("The given equation is not that of a circle.")
+
+ if S.Zero in (a, b) or a != b:
+ raise GeometryError("The given equation is not that of a circle.")
+
+ center_x = -c/a/2
+ center_y = -d/b/2
+ r2 = (center_x**2) + (center_y**2) - e/a
+
+ return Circle((center_x, center_y), sqrt(r2), evaluate=evaluate)
+
+ else:
+ c, r = None, None
+ if len(args) == 3:
+ args = [Point(a, dim=2, evaluate=evaluate) for a in args]
+ t = Triangle(*args)
+ if not isinstance(t, Triangle):
+ return t
+ c = t.circumcenter
+ r = t.circumradius
+ elif len(args) == 2:
+ # Assume (center, radius) pair
+ c = Point(args[0], dim=2, evaluate=evaluate)
+ r = args[1]
+ # this will prohibit imaginary radius
+ try:
+ r = Point(r, 0, evaluate=evaluate).x
+ except ValueError:
+ raise GeometryError("Circle with imaginary radius is not permitted")
+
+ if not (c is None or r is None):
+ if r == 0:
+ return c
+ return GeometryEntity.__new__(cls, c, r, **kwargs)
+
+ raise GeometryError("Circle.__new__ received unknown arguments")
+
+ def _eval_evalf(self, prec=15, **options):
+ pt, r = self.args
+ dps = prec_to_dps(prec)
+ pt = pt.evalf(n=dps, **options)
+ r = r.evalf(n=dps, **options)
+ return self.func(pt, r, evaluate=False)
+
+ @property
+ def circumference(self):
+ """The circumference of the circle.
+
+ Returns
+ =======
+
+ circumference : number or SymPy expression
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Circle
+ >>> c1 = Circle(Point(3, 4), 6)
+ >>> c1.circumference
+ 12*pi
+
+ """
+ return 2 * S.Pi * self.radius
+
+ def equation(self, x='x', y='y'):
+ """The equation of the circle.
+
+ Parameters
+ ==========
+
+ x : str or Symbol, optional
+ Default value is 'x'.
+ y : str or Symbol, optional
+ Default value is 'y'.
+
+ Returns
+ =======
+
+ equation : SymPy expression
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Circle
+ >>> c1 = Circle(Point(0, 0), 5)
+ >>> c1.equation()
+ x**2 + y**2 - 25
+
+ """
+ x = _symbol(x, real=True)
+ y = _symbol(y, real=True)
+ t1 = (x - self.center.x)**2
+ t2 = (y - self.center.y)**2
+ return t1 + t2 - self.major**2
+
+ def intersection(self, o):
+ """The intersection of this circle with another geometrical entity.
+
+ Parameters
+ ==========
+
+ o : GeometryEntity
+
+ Returns
+ =======
+
+ intersection : list of GeometryEntities
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Circle, Line, Ray
+ >>> p1, p2, p3 = Point(0, 0), Point(5, 5), Point(6, 0)
+ >>> p4 = Point(5, 0)
+ >>> c1 = Circle(p1, 5)
+ >>> c1.intersection(p2)
+ []
+ >>> c1.intersection(p4)
+ [Point2D(5, 0)]
+ >>> c1.intersection(Ray(p1, p2))
+ [Point2D(5*sqrt(2)/2, 5*sqrt(2)/2)]
+ >>> c1.intersection(Line(p2, p3))
+ []
+
+ """
+ return Ellipse.intersection(self, o)
+
+ @property
+ def radius(self):
+ """The radius of the circle.
+
+ Returns
+ =======
+
+ radius : number or SymPy expression
+
+ See Also
+ ========
+
+ Ellipse.major, Ellipse.minor, Ellipse.hradius, Ellipse.vradius
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Circle
+ >>> c1 = Circle(Point(3, 4), 6)
+ >>> c1.radius
+ 6
+
+ """
+ return self.args[1]
+
+ def reflect(self, line):
+ """Override GeometryEntity.reflect since the radius
+ is not a GeometryEntity.
+
+ Examples
+ ========
+
+ >>> from sympy import Circle, Line
+ >>> Circle((0, 1), 1).reflect(Line((0, 0), (1, 1)))
+ Circle(Point2D(1, 0), -1)
+ """
+ c = self.center
+ c = c.reflect(line)
+ return self.func(c, -self.radius)
+
+ def scale(self, x=1, y=1, pt=None):
+ """Override GeometryEntity.scale since the radius
+ is not a GeometryEntity.
+
+ Examples
+ ========
+
+ >>> from sympy import Circle
+ >>> Circle((0, 0), 1).scale(2, 2)
+ Circle(Point2D(0, 0), 2)
+ >>> Circle((0, 0), 1).scale(2, 4)
+ Ellipse(Point2D(0, 0), 2, 4)
+ """
+ c = self.center
+ if pt:
+ pt = Point(pt, dim=2)
+ return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+ c = c.scale(x, y)
+ x, y = [abs(i) for i in (x, y)]
+ if x == y:
+ return self.func(c, x*self.radius)
+ h = v = self.radius
+ return Ellipse(c, hradius=h*x, vradius=v*y)
+
+ @property
+ def vradius(self):
+ """
+ This Ellipse property is an alias for the Circle's radius.
+
+ Whereas hradius, major and minor can use Ellipse's conventions,
+ the vradius does not exist for a circle. It is always a positive
+ value in order that the Circle, like Polygons, will have an
+ area that can be positive or negative as determined by the sign
+ of the hradius.
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Circle
+ >>> c1 = Circle(Point(3, 4), 6)
+ >>> c1.vradius
+ 6
+ """
+ return abs(self.radius)
+
+
+from .polygon import Polygon, Triangle
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/entity.py b/janus/lib/python3.10/site-packages/sympy/geometry/entity.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ea1e807542c43eb955c2d778cec0f101d78bdce
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/geometry/entity.py
@@ -0,0 +1,641 @@
+"""The definition of the base geometrical entity with attributes common to
+all derived geometrical entities.
+
+Contains
+========
+
+GeometryEntity
+GeometricSet
+
+Notes
+=====
+
+A GeometryEntity is any object that has special geometric properties.
+A GeometrySet is a superclass of any GeometryEntity that can also
+be viewed as a sympy.sets.Set. In particular, points are the only
+GeometryEntity not considered a Set.
+
+Rn is a GeometrySet representing n-dimensional Euclidean space. R2 and
+R3 are currently the only ambient spaces implemented.
+
+"""
+from __future__ import annotations
+
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.evalf import EvalfMixin, N
+from sympy.core.numbers import oo
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.trigonometric import cos, sin, atan
+from sympy.matrices import eye
+from sympy.multipledispatch import dispatch
+from sympy.printing import sstr
+from sympy.sets import Set, Union, FiniteSet
+from sympy.sets.handlers.intersection import intersection_sets
+from sympy.sets.handlers.union import union_sets
+from sympy.solvers.solvers import solve
+from sympy.utilities.misc import func_name
+from sympy.utilities.iterables import is_sequence
+
+
+# How entities are ordered; used by __cmp__ in GeometryEntity
+ordering_of_classes = [
+ "Point2D",
+ "Point3D",
+ "Point",
+ "Segment2D",
+ "Ray2D",
+ "Line2D",
+ "Segment3D",
+ "Line3D",
+ "Ray3D",
+ "Segment",
+ "Ray",
+ "Line",
+ "Plane",
+ "Triangle",
+ "RegularPolygon",
+ "Polygon",
+ "Circle",
+ "Ellipse",
+ "Curve",
+ "Parabola"
+]
+
+
+x, y = [Dummy('entity_dummy') for i in range(2)]
+T = Dummy('entity_dummy', real=True)
+
+
+class GeometryEntity(Basic, EvalfMixin):
+ """The base class for all geometrical entities.
+
+ This class does not represent any particular geometric entity, it only
+ provides the implementation of some methods common to all subclasses.
+
+ """
+
+ __slots__: tuple[str, ...] = ()
+
+ def __cmp__(self, other):
+ """Comparison of two GeometryEntities."""
+ n1 = self.__class__.__name__
+ n2 = other.__class__.__name__
+ c = (n1 > n2) - (n1 < n2)
+ if not c:
+ return 0
+
+ i1 = -1
+ for cls in self.__class__.__mro__:
+ try:
+ i1 = ordering_of_classes.index(cls.__name__)
+ break
+ except ValueError:
+ i1 = -1
+ if i1 == -1:
+ return c
+
+ i2 = -1
+ for cls in other.__class__.__mro__:
+ try:
+ i2 = ordering_of_classes.index(cls.__name__)
+ break
+ except ValueError:
+ i2 = -1
+ if i2 == -1:
+ return c
+
+ return (i1 > i2) - (i1 < i2)
+
+ def __contains__(self, other):
+ """Subclasses should implement this method for anything more complex than equality."""
+ if type(self) is type(other):
+ return self == other
+ raise NotImplementedError()
+
+ def __getnewargs__(self):
+ """Returns a tuple that will be passed to __new__ on unpickling."""
+ return tuple(self.args)
+
+ def __ne__(self, o):
+ """Test inequality of two geometrical entities."""
+ return not self == o
+
+ def __new__(cls, *args, **kwargs):
+ # Points are sequences, but they should not
+ # be converted to Tuples, so use this detection function instead.
+ def is_seq_and_not_point(a):
+ # we cannot use isinstance(a, Point) since we cannot import Point
+ if hasattr(a, 'is_Point') and a.is_Point:
+ return False
+ return is_sequence(a)
+
+ args = [Tuple(*a) if is_seq_and_not_point(a) else sympify(a) for a in args]
+ return Basic.__new__(cls, *args)
+
+ def __radd__(self, a):
+ """Implementation of reverse add method."""
+ return a.__add__(self)
+
+ def __rtruediv__(self, a):
+ """Implementation of reverse division method."""
+ return a.__truediv__(self)
+
+ def __repr__(self):
+ """String representation of a GeometryEntity that can be evaluated
+ by sympy."""
+ return type(self).__name__ + repr(self.args)
+
+ def __rmul__(self, a):
+ """Implementation of reverse multiplication method."""
+ return a.__mul__(self)
+
+ def __rsub__(self, a):
+ """Implementation of reverse subtraction method."""
+ return a.__sub__(self)
+
+ def __str__(self):
+ """String representation of a GeometryEntity."""
+ return type(self).__name__ + sstr(self.args)
+
+ def _eval_subs(self, old, new):
+ from sympy.geometry.point import Point, Point3D
+ if is_sequence(old) or is_sequence(new):
+ if isinstance(self, Point3D):
+ old = Point3D(old)
+ new = Point3D(new)
+ else:
+ old = Point(old)
+ new = Point(new)
+ return self._subs(old, new)
+
+ def _repr_svg_(self):
+ """SVG representation of a GeometryEntity suitable for IPython"""
+
+ try:
+ bounds = self.bounds
+ except (NotImplementedError, TypeError):
+ # if we have no SVG representation, return None so IPython
+ # will fall back to the next representation
+ return None
+
+ if not all(x.is_number and x.is_finite for x in bounds):
+ return None
+
+ svg_top = ''''
+ ).format(transform, svg)
+
+ def _svg(self, scale_factor=1., fill_color="#66cc99"):
+ """Returns SVG path element for the GeometryEntity.
+
+ Parameters
+ ==========
+
+ scale_factor : float
+ Multiplication factor for the SVG stroke-width. Default is 1.
+ fill_color : str, optional
+ Hex string for fill color. Default is "#66cc99".
+ """
+ raise NotImplementedError()
+
+ def _sympy_(self):
+ return self
+
+ @property
+ def ambient_dimension(self):
+ """What is the dimension of the space that the object is contained in?"""
+ raise NotImplementedError()
+
+ @property
+ def bounds(self):
+ """Return a tuple (xmin, ymin, xmax, ymax) representing the bounding
+ rectangle for the geometric figure.
+
+ """
+
+ raise NotImplementedError()
+
+ def encloses(self, o):
+ """
+ Return True if o is inside (not on or outside) the boundaries of self.
+
+ The object will be decomposed into Points and individual Entities need
+ only define an encloses_point method for their class.
+
+ See Also
+ ========
+
+ sympy.geometry.ellipse.Ellipse.encloses_point
+ sympy.geometry.polygon.Polygon.encloses_point
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon, Point, Polygon
+ >>> t = Polygon(*RegularPolygon(Point(0, 0), 1, 3).vertices)
+ >>> t2 = Polygon(*RegularPolygon(Point(0, 0), 2, 3).vertices)
+ >>> t2.encloses(t)
+ True
+ >>> t.encloses(t2)
+ False
+
+ """
+
+ from sympy.geometry.point import Point
+ from sympy.geometry.line import Segment, Ray, Line
+ from sympy.geometry.ellipse import Ellipse
+ from sympy.geometry.polygon import Polygon, RegularPolygon
+
+ if isinstance(o, Point):
+ return self.encloses_point(o)
+ elif isinstance(o, Segment):
+ return all(self.encloses_point(x) for x in o.points)
+ elif isinstance(o, (Ray, Line)):
+ return False
+ elif isinstance(o, Ellipse):
+ return self.encloses_point(o.center) and \
+ self.encloses_point(
+ Point(o.center.x + o.hradius, o.center.y)) and \
+ not self.intersection(o)
+ elif isinstance(o, Polygon):
+ if isinstance(o, RegularPolygon):
+ if not self.encloses_point(o.center):
+ return False
+ return all(self.encloses_point(v) for v in o.vertices)
+ raise NotImplementedError()
+
+ def equals(self, o):
+ return self == o
+
+ def intersection(self, o):
+ """
+ Returns a list of all of the intersections of self with o.
+
+ Notes
+ =====
+
+ An entity is not required to implement this method.
+
+ If two different types of entities can intersect, the item with
+ higher index in ordering_of_classes should implement
+ intersections with anything having a lower index.
+
+ See Also
+ ========
+
+ sympy.geometry.util.intersection
+
+ """
+ raise NotImplementedError()
+
+ def is_similar(self, other):
+ """Is this geometrical entity similar to another geometrical entity?
+
+ Two entities are similar if a uniform scaling (enlarging or
+ shrinking) of one of the entities will allow one to obtain the other.
+
+ Notes
+ =====
+
+ This method is not intended to be used directly but rather
+ through the `are_similar` function found in util.py.
+ An entity is not required to implement this method.
+ If two different types of entities can be similar, it is only
+ required that one of them be able to determine this.
+
+ See Also
+ ========
+
+ scale
+
+ """
+ raise NotImplementedError()
+
+ def reflect(self, line):
+ """
+ Reflects an object across a line.
+
+ Parameters
+ ==========
+
+ line: Line
+
+ Examples
+ ========
+
+ >>> from sympy import pi, sqrt, Line, RegularPolygon
+ >>> l = Line((0, pi), slope=sqrt(2))
+ >>> pent = RegularPolygon((1, 2), 1, 5)
+ >>> rpent = pent.reflect(l)
+ >>> rpent
+ RegularPolygon(Point2D(-2*sqrt(2)*pi/3 - 1/3 + 4*sqrt(2)/3, 2/3 + 2*sqrt(2)/3 + 2*pi/3), -1, 5, -atan(2*sqrt(2)) + 3*pi/5)
+
+ >>> from sympy import pi, Line, Circle, Point
+ >>> l = Line((0, pi), slope=1)
+ >>> circ = Circle(Point(0, 0), 5)
+ >>> rcirc = circ.reflect(l)
+ >>> rcirc
+ Circle(Point2D(-pi, pi), -5)
+
+ """
+ from sympy.geometry.point import Point
+
+ g = self
+ l = line
+ o = Point(0, 0)
+ if l.slope.is_zero:
+ v = l.args[0].y
+ if not v: # x-axis
+ return g.scale(y=-1)
+ reps = [(p, p.translate(y=2*(v - p.y))) for p in g.atoms(Point)]
+ elif l.slope is oo:
+ v = l.args[0].x
+ if not v: # y-axis
+ return g.scale(x=-1)
+ reps = [(p, p.translate(x=2*(v - p.x))) for p in g.atoms(Point)]
+ else:
+ if not hasattr(g, 'reflect') and not all(
+ isinstance(arg, Point) for arg in g.args):
+ raise NotImplementedError(
+ 'reflect undefined or non-Point args in %s' % g)
+ a = atan(l.slope)
+ c = l.coefficients
+ d = -c[-1]/c[1] # y-intercept
+ # apply the transform to a single point
+ xf = Point(x, y)
+ xf = xf.translate(y=-d).rotate(-a, o).scale(y=-1
+ ).rotate(a, o).translate(y=d)
+ # replace every point using that transform
+ reps = [(p, xf.xreplace({x: p.x, y: p.y})) for p in g.atoms(Point)]
+ return g.xreplace(dict(reps))
+
+ def rotate(self, angle, pt=None):
+ """Rotate ``angle`` radians counterclockwise about Point ``pt``.
+
+ The default pt is the origin, Point(0, 0)
+
+ See Also
+ ========
+
+ scale, translate
+
+ Examples
+ ========
+
+ >>> from sympy import Point, RegularPolygon, Polygon, pi
+ >>> t = Polygon(*RegularPolygon(Point(0, 0), 1, 3).vertices)
+ >>> t # vertex on x axis
+ Triangle(Point2D(1, 0), Point2D(-1/2, sqrt(3)/2), Point2D(-1/2, -sqrt(3)/2))
+ >>> t.rotate(pi/2) # vertex on y axis now
+ Triangle(Point2D(0, 1), Point2D(-sqrt(3)/2, -1/2), Point2D(sqrt(3)/2, -1/2))
+
+ """
+ newargs = []
+ for a in self.args:
+ if isinstance(a, GeometryEntity):
+ newargs.append(a.rotate(angle, pt))
+ else:
+ newargs.append(a)
+ return type(self)(*newargs)
+
+ def scale(self, x=1, y=1, pt=None):
+ """Scale the object by multiplying the x,y-coordinates by x and y.
+
+ If pt is given, the scaling is done relative to that point; the
+ object is shifted by -pt, scaled, and shifted by pt.
+
+ See Also
+ ========
+
+ rotate, translate
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon, Point, Polygon
+ >>> t = Polygon(*RegularPolygon(Point(0, 0), 1, 3).vertices)
+ >>> t
+ Triangle(Point2D(1, 0), Point2D(-1/2, sqrt(3)/2), Point2D(-1/2, -sqrt(3)/2))
+ >>> t.scale(2)
+ Triangle(Point2D(2, 0), Point2D(-1, sqrt(3)/2), Point2D(-1, -sqrt(3)/2))
+ >>> t.scale(2, 2)
+ Triangle(Point2D(2, 0), Point2D(-1, sqrt(3)), Point2D(-1, -sqrt(3)))
+
+ """
+ from sympy.geometry.point import Point
+ if pt:
+ pt = Point(pt, dim=2)
+ return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+ return type(self)(*[a.scale(x, y) for a in self.args]) # if this fails, override this class
+
+ def translate(self, x=0, y=0):
+ """Shift the object by adding to the x,y-coordinates the values x and y.
+
+ See Also
+ ========
+
+ rotate, scale
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon, Point, Polygon
+ >>> t = Polygon(*RegularPolygon(Point(0, 0), 1, 3).vertices)
+ >>> t
+ Triangle(Point2D(1, 0), Point2D(-1/2, sqrt(3)/2), Point2D(-1/2, -sqrt(3)/2))
+ >>> t.translate(2)
+ Triangle(Point2D(3, 0), Point2D(3/2, sqrt(3)/2), Point2D(3/2, -sqrt(3)/2))
+ >>> t.translate(2, 2)
+ Triangle(Point2D(3, 2), Point2D(3/2, sqrt(3)/2 + 2), Point2D(3/2, 2 - sqrt(3)/2))
+
+ """
+ newargs = []
+ for a in self.args:
+ if isinstance(a, GeometryEntity):
+ newargs.append(a.translate(x, y))
+ else:
+ newargs.append(a)
+ return self.func(*newargs)
+
+ def parameter_value(self, other, t):
+ """Return the parameter corresponding to the given point.
+ Evaluating an arbitrary point of the entity at this parameter
+ value will return the given point.
+
+ Examples
+ ========
+
+ >>> from sympy import Line, Point
+ >>> from sympy.abc import t
+ >>> a = Point(0, 0)
+ >>> b = Point(2, 2)
+ >>> Line(a, b).parameter_value((1, 1), t)
+ {t: 1/2}
+ >>> Line(a, b).arbitrary_point(t).subs(_)
+ Point2D(1, 1)
+ """
+ from sympy.geometry.point import Point
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if not isinstance(other, Point):
+ raise ValueError("other must be a point")
+ sol = solve(self.arbitrary_point(T) - other, T, dict=True)
+ if not sol:
+ raise ValueError("Given point is not on %s" % func_name(self))
+ return {t: sol[0][T]}
+
+
+class GeometrySet(GeometryEntity, Set):
+ """Parent class of all GeometryEntity that are also Sets
+ (compatible with sympy.sets)
+ """
+ __slots__ = ()
+
+ def _contains(self, other):
+ """sympy.sets uses the _contains method, so include it for compatibility."""
+
+ if isinstance(other, Set) and other.is_FiniteSet:
+ return all(self.__contains__(i) for i in other)
+
+ return self.__contains__(other)
+
+@dispatch(GeometrySet, Set) # type:ignore # noqa:F811
+def union_sets(self, o): # noqa:F811
+ """ Returns the union of self and o
+ for use with sympy.sets.Set, if possible. """
+
+
+ # if its a FiniteSet, merge any points
+ # we contain and return a union with the rest
+ if o.is_FiniteSet:
+ other_points = [p for p in o if not self._contains(p)]
+ if len(other_points) == len(o):
+ return None
+ return Union(self, FiniteSet(*other_points))
+ if self._contains(o):
+ return self
+ return None
+
+
+@dispatch(GeometrySet, Set) # type: ignore # noqa:F811
+def intersection_sets(self, o): # noqa:F811
+ """ Returns a sympy.sets.Set of intersection objects,
+ if possible. """
+
+ from sympy.geometry.point import Point
+
+ try:
+ # if o is a FiniteSet, find the intersection directly
+ # to avoid infinite recursion
+ if o.is_FiniteSet:
+ inter = FiniteSet(*(p for p in o if self.contains(p)))
+ else:
+ inter = self.intersection(o)
+ except NotImplementedError:
+ # sympy.sets.Set.reduce expects None if an object
+ # doesn't know how to simplify
+ return None
+
+ # put the points in a FiniteSet
+ points = FiniteSet(*[p for p in inter if isinstance(p, Point)])
+ non_points = [p for p in inter if not isinstance(p, Point)]
+
+ return Union(*(non_points + [points]))
+
+def translate(x, y):
+ """Return the matrix to translate a 2-D point by x and y."""
+ rv = eye(3)
+ rv[2, 0] = x
+ rv[2, 1] = y
+ return rv
+
+
+def scale(x, y, pt=None):
+ """Return the matrix to multiply a 2-D point's coordinates by x and y.
+
+ If pt is given, the scaling is done relative to that point."""
+ rv = eye(3)
+ rv[0, 0] = x
+ rv[1, 1] = y
+ if pt:
+ from sympy.geometry.point import Point
+ pt = Point(pt, dim=2)
+ tr1 = translate(*(-pt).args)
+ tr2 = translate(*pt.args)
+ return tr1*rv*tr2
+ return rv
+
+
+def rotate(th):
+ """Return the matrix to rotate a 2-D point about the origin by ``angle``.
+
+ The angle is measured in radians. To Point a point about a point other
+ then the origin, translate the Point, do the rotation, and
+ translate it back:
+
+ >>> from sympy.geometry.entity import rotate, translate
+ >>> from sympy import Point, pi
+ >>> rot_about_11 = translate(-1, -1)*rotate(pi/2)*translate(1, 1)
+ >>> Point(1, 1).transform(rot_about_11)
+ Point2D(1, 1)
+ >>> Point(0, 0).transform(rot_about_11)
+ Point2D(2, 0)
+ """
+ s = sin(th)
+ rv = eye(3)*cos(th)
+ rv[0, 1] = s
+ rv[1, 0] = -s
+ rv[2, 2] = 1
+ return rv
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/exceptions.py b/janus/lib/python3.10/site-packages/sympy/geometry/exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..41d97af718de2cebad3accefcd60e43ccf74a3f6
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/geometry/exceptions.py
@@ -0,0 +1,5 @@
+"""Geometry Errors."""
+
+class GeometryError(ValueError):
+ """An exception raised by classes in the geometry module."""
+ pass
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/line.py b/janus/lib/python3.10/site-packages/sympy/geometry/line.py
new file mode 100644
index 0000000000000000000000000000000000000000..e9b29b5766bd4157d2cddd6a403c142768224ac8
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/geometry/line.py
@@ -0,0 +1,2877 @@
+"""Line-like geometrical entities.
+
+Contains
+========
+LinearEntity
+Line
+Ray
+Segment
+LinearEntity2D
+Line2D
+Ray2D
+Segment2D
+LinearEntity3D
+Line3D
+Ray3D
+Segment3D
+
+"""
+
+from sympy.core.containers import Tuple
+from sympy.core.evalf import N
+from sympy.core.expr import Expr
+from sympy.core.numbers import Rational, oo, Float
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import _symbol, Dummy, uniquely_named_symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (_pi_coeff, acos, tan, atan2)
+from .entity import GeometryEntity, GeometrySet
+from .exceptions import GeometryError
+from .point import Point, Point3D
+from .util import find, intersection
+from sympy.logic.boolalg import And
+from sympy.matrices import Matrix
+from sympy.sets.sets import Intersection
+from sympy.simplify.simplify import simplify
+from sympy.solvers.solvers import solve
+from sympy.solvers.solveset import linear_coeffs
+from sympy.utilities.misc import Undecidable, filldedent
+
+
+import random
+
+
+t, u = [Dummy('line_dummy') for i in range(2)]
+
+
+class LinearEntity(GeometrySet):
+ """A base class for all linear entities (Line, Ray and Segment)
+ in n-dimensional Euclidean space.
+
+ Attributes
+ ==========
+
+ ambient_dimension
+ direction
+ length
+ p1
+ p2
+ points
+
+ Notes
+ =====
+
+ This is an abstract class and is not meant to be instantiated.
+
+ See Also
+ ========
+
+ sympy.geometry.entity.GeometryEntity
+
+ """
+ def __new__(cls, p1, p2=None, **kwargs):
+ p1, p2 = Point._normalize_dimension(p1, p2)
+ if p1 == p2:
+ # sometimes we return a single point if we are not given two unique
+ # points. This is done in the specific subclass
+ raise ValueError(
+ "%s.__new__ requires two unique Points." % cls.__name__)
+ if len(p1) != len(p2):
+ raise ValueError(
+ "%s.__new__ requires two Points of equal dimension." % cls.__name__)
+
+ return GeometryEntity.__new__(cls, p1, p2, **kwargs)
+
+ def __contains__(self, other):
+ """Return a definitive answer or else raise an error if it cannot
+ be determined that other is on the boundaries of self."""
+ result = self.contains(other)
+
+ if result is not None:
+ return result
+ else:
+ raise Undecidable(
+ "Cannot decide whether '%s' contains '%s'" % (self, other))
+
+ def _span_test(self, other):
+ """Test whether the point `other` lies in the positive span of `self`.
+ A point x is 'in front' of a point y if x.dot(y) >= 0. Return
+ -1 if `other` is behind `self.p1`, 0 if `other` is `self.p1` and
+ and 1 if `other` is in front of `self.p1`."""
+ if self.p1 == other:
+ return 0
+
+ rel_pos = other - self.p1
+ d = self.direction
+ if d.dot(rel_pos) > 0:
+ return 1
+ return -1
+
+ @property
+ def ambient_dimension(self):
+ """A property method that returns the dimension of LinearEntity
+ object.
+
+ Parameters
+ ==========
+
+ p1 : LinearEntity
+
+ Returns
+ =======
+
+ dimension : integer
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(1, 1)
+ >>> l1 = Line(p1, p2)
+ >>> l1.ambient_dimension
+ 2
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0, 0), Point(1, 1, 1)
+ >>> l1 = Line(p1, p2)
+ >>> l1.ambient_dimension
+ 3
+
+ """
+ return len(self.p1)
+
+ def angle_between(l1, l2):
+ """Return the non-reflex angle formed by rays emanating from
+ the origin with directions the same as the direction vectors
+ of the linear entities.
+
+ Parameters
+ ==========
+
+ l1 : LinearEntity
+ l2 : LinearEntity
+
+ Returns
+ =======
+
+ angle : angle in radians
+
+ Notes
+ =====
+
+ From the dot product of vectors v1 and v2 it is known that:
+
+ ``dot(v1, v2) = |v1|*|v2|*cos(A)``
+
+ where A is the angle formed between the two vectors. We can
+ get the directional vectors of the two lines and readily
+ find the angle between the two using the above formula.
+
+ See Also
+ ========
+
+ is_perpendicular, Ray2D.closing_angle
+
+ Examples
+ ========
+
+ >>> from sympy import Line
+ >>> e = Line((0, 0), (1, 0))
+ >>> ne = Line((0, 0), (1, 1))
+ >>> sw = Line((1, 1), (0, 0))
+ >>> ne.angle_between(e)
+ pi/4
+ >>> sw.angle_between(e)
+ 3*pi/4
+
+ To obtain the non-obtuse angle at the intersection of lines, use
+ the ``smallest_angle_between`` method:
+
+ >>> sw.smallest_angle_between(e)
+ pi/4
+
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(-1, 2, 0)
+ >>> l1, l2 = Line3D(p1, p2), Line3D(p2, p3)
+ >>> l1.angle_between(l2)
+ acos(-sqrt(2)/3)
+ >>> l1.smallest_angle_between(l2)
+ acos(sqrt(2)/3)
+ """
+ if not isinstance(l1, LinearEntity) and not isinstance(l2, LinearEntity):
+ raise TypeError('Must pass only LinearEntity objects')
+
+ v1, v2 = l1.direction, l2.direction
+ return acos(v1.dot(v2)/(abs(v1)*abs(v2)))
+
+ def smallest_angle_between(l1, l2):
+ """Return the smallest angle formed at the intersection of the
+ lines containing the linear entities.
+
+ Parameters
+ ==========
+
+ l1 : LinearEntity
+ l2 : LinearEntity
+
+ Returns
+ =======
+
+ angle : angle in radians
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2, p3 = Point(0, 0), Point(0, 4), Point(2, -2)
+ >>> l1, l2 = Line(p1, p2), Line(p1, p3)
+ >>> l1.smallest_angle_between(l2)
+ pi/4
+
+ See Also
+ ========
+
+ angle_between, is_perpendicular, Ray2D.closing_angle
+ """
+ if not isinstance(l1, LinearEntity) and not isinstance(l2, LinearEntity):
+ raise TypeError('Must pass only LinearEntity objects')
+
+ v1, v2 = l1.direction, l2.direction
+ return acos(abs(v1.dot(v2))/(abs(v1)*abs(v2)))
+
+ def arbitrary_point(self, parameter='t'):
+ """A parameterized point on the Line.
+
+ Parameters
+ ==========
+
+ parameter : str, optional
+ The name of the parameter which will be used for the parametric
+ point. The default value is 't'. When this parameter is 0, the
+ first point used to define the line will be returned, and when
+ it is 1 the second point will be returned.
+
+ Returns
+ =======
+
+ point : Point
+
+ Raises
+ ======
+
+ ValueError
+ When ``parameter`` already appears in the Line's definition.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(1, 0), Point(5, 3)
+ >>> l1 = Line(p1, p2)
+ >>> l1.arbitrary_point()
+ Point2D(4*t + 1, 3*t)
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2 = Point3D(1, 0, 0), Point3D(5, 3, 1)
+ >>> l1 = Line3D(p1, p2)
+ >>> l1.arbitrary_point()
+ Point3D(4*t + 1, 3*t, t)
+
+ """
+ t = _symbol(parameter, real=True)
+ if t.name in (f.name for f in self.free_symbols):
+ raise ValueError(filldedent('''
+ Symbol %s already appears in object
+ and cannot be used as a parameter.
+ ''' % t.name))
+ # multiply on the right so the variable gets
+ # combined with the coordinates of the point
+ return self.p1 + (self.p2 - self.p1)*t
+
+ @staticmethod
+ def are_concurrent(*lines):
+ """Is a sequence of linear entities concurrent?
+
+ Two or more linear entities are concurrent if they all
+ intersect at a single point.
+
+ Parameters
+ ==========
+
+ lines
+ A sequence of linear entities.
+
+ Returns
+ =======
+
+ True : if the set of linear entities intersect in one point
+ False : otherwise.
+
+ See Also
+ ========
+
+ sympy.geometry.util.intersection
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(3, 5)
+ >>> p3, p4 = Point(-2, -2), Point(0, 2)
+ >>> l1, l2, l3 = Line(p1, p2), Line(p1, p3), Line(p1, p4)
+ >>> Line.are_concurrent(l1, l2, l3)
+ True
+ >>> l4 = Line(p2, p3)
+ >>> Line.are_concurrent(l2, l3, l4)
+ False
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2 = Point3D(0, 0, 0), Point3D(3, 5, 2)
+ >>> p3, p4 = Point3D(-2, -2, -2), Point3D(0, 2, 1)
+ >>> l1, l2, l3 = Line3D(p1, p2), Line3D(p1, p3), Line3D(p1, p4)
+ >>> Line3D.are_concurrent(l1, l2, l3)
+ True
+ >>> l4 = Line3D(p2, p3)
+ >>> Line3D.are_concurrent(l2, l3, l4)
+ False
+
+ """
+ common_points = Intersection(*lines)
+ if common_points.is_FiniteSet and len(common_points) == 1:
+ return True
+ return False
+
+ def contains(self, other):
+ """Subclasses should implement this method and should return
+ True if other is on the boundaries of self;
+ False if not on the boundaries of self;
+ None if a determination cannot be made."""
+ raise NotImplementedError()
+
+ @property
+ def direction(self):
+ """The direction vector of the LinearEntity.
+
+ Returns
+ =======
+
+ p : a Point; the ray from the origin to this point is the
+ direction of `self`
+
+ Examples
+ ========
+
+ >>> from sympy import Line
+ >>> a, b = (1, 1), (1, 3)
+ >>> Line(a, b).direction
+ Point2D(0, 2)
+ >>> Line(b, a).direction
+ Point2D(0, -2)
+
+ This can be reported so the distance from the origin is 1:
+
+ >>> Line(b, a).direction.unit
+ Point2D(0, -1)
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point.unit
+
+ """
+ return self.p2 - self.p1
+
+ def intersection(self, other):
+ """The intersection with another geometrical entity.
+
+ Parameters
+ ==========
+
+ o : Point or LinearEntity
+
+ Returns
+ =======
+
+ intersection : list of geometrical entities
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line, Segment
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(7, 7)
+ >>> l1 = Line(p1, p2)
+ >>> l1.intersection(p3)
+ [Point2D(7, 7)]
+ >>> p4, p5 = Point(5, 0), Point(0, 3)
+ >>> l2 = Line(p4, p5)
+ >>> l1.intersection(l2)
+ [Point2D(15/8, 15/8)]
+ >>> p6, p7 = Point(0, 5), Point(2, 6)
+ >>> s1 = Segment(p6, p7)
+ >>> l1.intersection(s1)
+ []
+ >>> from sympy import Point3D, Line3D, Segment3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(7, 7, 7)
+ >>> l1 = Line3D(p1, p2)
+ >>> l1.intersection(p3)
+ [Point3D(7, 7, 7)]
+ >>> l1 = Line3D(Point3D(4,19,12), Point3D(5,25,17))
+ >>> l2 = Line3D(Point3D(-3, -15, -19), direction_ratio=[2,8,8])
+ >>> l1.intersection(l2)
+ [Point3D(1, 1, -3)]
+ >>> p6, p7 = Point3D(0, 5, 2), Point3D(2, 6, 3)
+ >>> s1 = Segment3D(p6, p7)
+ >>> l1.intersection(s1)
+ []
+
+ """
+ def intersect_parallel_rays(ray1, ray2):
+ if ray1.direction.dot(ray2.direction) > 0:
+ # rays point in the same direction
+ # so return the one that is "in front"
+ return [ray2] if ray1._span_test(ray2.p1) >= 0 else [ray1]
+ else:
+ # rays point in opposite directions
+ st = ray1._span_test(ray2.p1)
+ if st < 0:
+ return []
+ elif st == 0:
+ return [ray2.p1]
+ return [Segment(ray1.p1, ray2.p1)]
+
+ def intersect_parallel_ray_and_segment(ray, seg):
+ st1, st2 = ray._span_test(seg.p1), ray._span_test(seg.p2)
+ if st1 < 0 and st2 < 0:
+ return []
+ elif st1 >= 0 and st2 >= 0:
+ return [seg]
+ elif st1 >= 0: # st2 < 0:
+ return [Segment(ray.p1, seg.p1)]
+ else: # st1 < 0 and st2 >= 0:
+ return [Segment(ray.p1, seg.p2)]
+
+ def intersect_parallel_segments(seg1, seg2):
+ if seg1.contains(seg2):
+ return [seg2]
+ if seg2.contains(seg1):
+ return [seg1]
+
+ # direct the segments so they're oriented the same way
+ if seg1.direction.dot(seg2.direction) < 0:
+ seg2 = Segment(seg2.p2, seg2.p1)
+ # order the segments so seg1 is "behind" seg2
+ if seg1._span_test(seg2.p1) < 0:
+ seg1, seg2 = seg2, seg1
+ if seg2._span_test(seg1.p2) < 0:
+ return []
+ return [Segment(seg2.p1, seg1.p2)]
+
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if other.is_Point:
+ if self.contains(other):
+ return [other]
+ else:
+ return []
+ elif isinstance(other, LinearEntity):
+ # break into cases based on whether
+ # the lines are parallel, non-parallel intersecting, or skew
+ pts = Point._normalize_dimension(self.p1, self.p2, other.p1, other.p2)
+ rank = Point.affine_rank(*pts)
+
+ if rank == 1:
+ # we're collinear
+ if isinstance(self, Line):
+ return [other]
+ if isinstance(other, Line):
+ return [self]
+
+ if isinstance(self, Ray) and isinstance(other, Ray):
+ return intersect_parallel_rays(self, other)
+ if isinstance(self, Ray) and isinstance(other, Segment):
+ return intersect_parallel_ray_and_segment(self, other)
+ if isinstance(self, Segment) and isinstance(other, Ray):
+ return intersect_parallel_ray_and_segment(other, self)
+ if isinstance(self, Segment) and isinstance(other, Segment):
+ return intersect_parallel_segments(self, other)
+ elif rank == 2:
+ # we're in the same plane
+ l1 = Line(*pts[:2])
+ l2 = Line(*pts[2:])
+
+ # check to see if we're parallel. If we are, we can't
+ # be intersecting, since the collinear case was already
+ # handled
+ if l1.direction.is_scalar_multiple(l2.direction):
+ return []
+
+ # find the intersection as if everything were lines
+ # by solving the equation t*d + p1 == s*d' + p1'
+ m = Matrix([l1.direction, -l2.direction]).transpose()
+ v = Matrix([l2.p1 - l1.p1]).transpose()
+
+ # we cannot use m.solve(v) because that only works for square matrices
+ m_rref, pivots = m.col_insert(2, v).rref(simplify=True)
+ # rank == 2 ensures we have 2 pivots, but let's check anyway
+ if len(pivots) != 2:
+ raise GeometryError("Failed when solving Mx=b when M={} and b={}".format(m, v))
+ coeff = m_rref[0, 2]
+ line_intersection = l1.direction*coeff + self.p1
+
+ # if both are lines, skip a containment check
+ if isinstance(self, Line) and isinstance(other, Line):
+ return [line_intersection]
+
+ if ((isinstance(self, Line) or
+ self.contains(line_intersection)) and
+ other.contains(line_intersection)):
+ return [line_intersection]
+ if not self.atoms(Float) and not other.atoms(Float):
+ # if it can fail when there are no Floats then
+ # maybe the following parametric check should be
+ # done
+ return []
+ # floats may fail exact containment so check that the
+ # arbitrary points, when equal, both give a
+ # non-negative parameter when the arbitrary point
+ # coordinates are equated
+ tu = solve(self.arbitrary_point(t) - other.arbitrary_point(u),
+ t, u, dict=True)[0]
+ def ok(p, l):
+ if isinstance(l, Line):
+ # p > -oo
+ return True
+ if isinstance(l, Ray):
+ # p >= 0
+ return p.is_nonnegative
+ if isinstance(l, Segment):
+ # 0 <= p <= 1
+ return p.is_nonnegative and (1 - p).is_nonnegative
+ raise ValueError("unexpected line type")
+ if ok(tu[t], self) and ok(tu[u], other):
+ return [line_intersection]
+ return []
+ else:
+ # we're skew
+ return []
+
+ return other.intersection(self)
+
+ def is_parallel(l1, l2):
+ """Are two linear entities parallel?
+
+ Parameters
+ ==========
+
+ l1 : LinearEntity
+ l2 : LinearEntity
+
+ Returns
+ =======
+
+ True : if l1 and l2 are parallel,
+ False : otherwise.
+
+ See Also
+ ========
+
+ coefficients
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(1, 1)
+ >>> p3, p4 = Point(3, 4), Point(6, 7)
+ >>> l1, l2 = Line(p1, p2), Line(p3, p4)
+ >>> Line.is_parallel(l1, l2)
+ True
+ >>> p5 = Point(6, 6)
+ >>> l3 = Line(p3, p5)
+ >>> Line.is_parallel(l1, l3)
+ False
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2 = Point3D(0, 0, 0), Point3D(3, 4, 5)
+ >>> p3, p4 = Point3D(2, 1, 1), Point3D(8, 9, 11)
+ >>> l1, l2 = Line3D(p1, p2), Line3D(p3, p4)
+ >>> Line3D.is_parallel(l1, l2)
+ True
+ >>> p5 = Point3D(6, 6, 6)
+ >>> l3 = Line3D(p3, p5)
+ >>> Line3D.is_parallel(l1, l3)
+ False
+
+ """
+ if not isinstance(l1, LinearEntity) and not isinstance(l2, LinearEntity):
+ raise TypeError('Must pass only LinearEntity objects')
+
+ return l1.direction.is_scalar_multiple(l2.direction)
+
+ def is_perpendicular(l1, l2):
+ """Are two linear entities perpendicular?
+
+ Parameters
+ ==========
+
+ l1 : LinearEntity
+ l2 : LinearEntity
+
+ Returns
+ =======
+
+ True : if l1 and l2 are perpendicular,
+ False : otherwise.
+
+ See Also
+ ========
+
+ coefficients
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(-1, 1)
+ >>> l1, l2 = Line(p1, p2), Line(p1, p3)
+ >>> l1.is_perpendicular(l2)
+ True
+ >>> p4 = Point(5, 3)
+ >>> l3 = Line(p1, p4)
+ >>> l1.is_perpendicular(l3)
+ False
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(-1, 2, 0)
+ >>> l1, l2 = Line3D(p1, p2), Line3D(p2, p3)
+ >>> l1.is_perpendicular(l2)
+ False
+ >>> p4 = Point3D(5, 3, 7)
+ >>> l3 = Line3D(p1, p4)
+ >>> l1.is_perpendicular(l3)
+ False
+
+ """
+ if not isinstance(l1, LinearEntity) and not isinstance(l2, LinearEntity):
+ raise TypeError('Must pass only LinearEntity objects')
+
+ return S.Zero.equals(l1.direction.dot(l2.direction))
+
+ def is_similar(self, other):
+ """
+ Return True if self and other are contained in the same line.
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2, p3 = Point(0, 1), Point(3, 4), Point(2, 3)
+ >>> l1 = Line(p1, p2)
+ >>> l2 = Line(p1, p3)
+ >>> l1.is_similar(l2)
+ True
+ """
+ l = Line(self.p1, self.p2)
+ return l.contains(other)
+
+ @property
+ def length(self):
+ """
+ The length of the line.
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(3, 5)
+ >>> l1 = Line(p1, p2)
+ >>> l1.length
+ oo
+ """
+ return S.Infinity
+
+ @property
+ def p1(self):
+ """The first defining point of a linear entity.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(5, 3)
+ >>> l = Line(p1, p2)
+ >>> l.p1
+ Point2D(0, 0)
+
+ """
+ return self.args[0]
+
+ @property
+ def p2(self):
+ """The second defining point of a linear entity.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(5, 3)
+ >>> l = Line(p1, p2)
+ >>> l.p2
+ Point2D(5, 3)
+
+ """
+ return self.args[1]
+
+ def parallel_line(self, p):
+ """Create a new Line parallel to this linear entity which passes
+ through the point `p`.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ line : Line
+
+ See Also
+ ========
+
+ is_parallel
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2, p3 = Point(0, 0), Point(2, 3), Point(-2, 2)
+ >>> l1 = Line(p1, p2)
+ >>> l2 = l1.parallel_line(p3)
+ >>> p3 in l2
+ True
+ >>> l1.is_parallel(l2)
+ True
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(2, 3, 4), Point3D(-2, 2, 0)
+ >>> l1 = Line3D(p1, p2)
+ >>> l2 = l1.parallel_line(p3)
+ >>> p3 in l2
+ True
+ >>> l1.is_parallel(l2)
+ True
+
+ """
+ p = Point(p, dim=self.ambient_dimension)
+ return Line(p, p + self.direction)
+
+ def perpendicular_line(self, p):
+ """Create a new Line perpendicular to this linear entity which passes
+ through the point `p`.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ line : Line
+
+ See Also
+ ========
+
+ sympy.geometry.line.LinearEntity.is_perpendicular, perpendicular_segment
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(2, 3, 4), Point3D(-2, 2, 0)
+ >>> L = Line3D(p1, p2)
+ >>> P = L.perpendicular_line(p3); P
+ Line3D(Point3D(-2, 2, 0), Point3D(4/29, 6/29, 8/29))
+ >>> L.is_perpendicular(P)
+ True
+
+ In 3D the, the first point used to define the line is the point
+ through which the perpendicular was required to pass; the
+ second point is (arbitrarily) contained in the given line:
+
+ >>> P.p2 in L
+ True
+ """
+ p = Point(p, dim=self.ambient_dimension)
+ if p in self:
+ p = p + self.direction.orthogonal_direction
+ return Line(p, self.projection(p))
+
+ def perpendicular_segment(self, p):
+ """Create a perpendicular line segment from `p` to this line.
+
+ The endpoints of the segment are ``p`` and the closest point in
+ the line containing self. (If self is not a line, the point might
+ not be in self.)
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ segment : Segment
+
+ Notes
+ =====
+
+ Returns `p` itself if `p` is on this linear entity.
+
+ See Also
+ ========
+
+ perpendicular_line
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(0, 2)
+ >>> l1 = Line(p1, p2)
+ >>> s1 = l1.perpendicular_segment(p3)
+ >>> l1.is_perpendicular(s1)
+ True
+ >>> p3 in s1
+ True
+ >>> l1.perpendicular_segment(Point(4, 0))
+ Segment2D(Point2D(4, 0), Point2D(2, 2))
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(0, 2, 0)
+ >>> l1 = Line3D(p1, p2)
+ >>> s1 = l1.perpendicular_segment(p3)
+ >>> l1.is_perpendicular(s1)
+ True
+ >>> p3 in s1
+ True
+ >>> l1.perpendicular_segment(Point3D(4, 0, 0))
+ Segment3D(Point3D(4, 0, 0), Point3D(4/3, 4/3, 4/3))
+
+ """
+ p = Point(p, dim=self.ambient_dimension)
+ if p in self:
+ return p
+ l = self.perpendicular_line(p)
+ # The intersection should be unique, so unpack the singleton
+ p2, = Intersection(Line(self.p1, self.p2), l)
+
+ return Segment(p, p2)
+
+ @property
+ def points(self):
+ """The two points used to define this linear entity.
+
+ Returns
+ =======
+
+ points : tuple of Points
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(5, 11)
+ >>> l1 = Line(p1, p2)
+ >>> l1.points
+ (Point2D(0, 0), Point2D(5, 11))
+
+ """
+ return (self.p1, self.p2)
+
+ def projection(self, other):
+ """Project a point, line, ray, or segment onto this linear entity.
+
+ Parameters
+ ==========
+
+ other : Point or LinearEntity (Line, Ray, Segment)
+
+ Returns
+ =======
+
+ projection : Point or LinearEntity (Line, Ray, Segment)
+ The return type matches the type of the parameter ``other``.
+
+ Raises
+ ======
+
+ GeometryError
+ When method is unable to perform projection.
+
+ Notes
+ =====
+
+ A projection involves taking the two points that define
+ the linear entity and projecting those points onto a
+ Line and then reforming the linear entity using these
+ projections.
+ A point P is projected onto a line L by finding the point
+ on L that is closest to P. This point is the intersection
+ of L and the line perpendicular to L that passes through P.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, perpendicular_line
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line, Segment, Rational
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(Rational(1, 2), 0)
+ >>> l1 = Line(p1, p2)
+ >>> l1.projection(p3)
+ Point2D(1/4, 1/4)
+ >>> p4, p5 = Point(10, 0), Point(12, 1)
+ >>> s1 = Segment(p4, p5)
+ >>> l1.projection(s1)
+ Segment2D(Point2D(5, 5), Point2D(13/2, 13/2))
+ >>> p1, p2, p3 = Point(0, 0, 1), Point(1, 1, 2), Point(2, 0, 1)
+ >>> l1 = Line(p1, p2)
+ >>> l1.projection(p3)
+ Point3D(2/3, 2/3, 5/3)
+ >>> p4, p5 = Point(10, 0, 1), Point(12, 1, 3)
+ >>> s1 = Segment(p4, p5)
+ >>> l1.projection(s1)
+ Segment3D(Point3D(10/3, 10/3, 13/3), Point3D(5, 5, 6))
+
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+
+ def proj_point(p):
+ return Point.project(p - self.p1, self.direction) + self.p1
+
+ if isinstance(other, Point):
+ return proj_point(other)
+ elif isinstance(other, LinearEntity):
+ p1, p2 = proj_point(other.p1), proj_point(other.p2)
+ # test to see if we're degenerate
+ if p1 == p2:
+ return p1
+ projected = other.__class__(p1, p2)
+ projected = Intersection(self, projected)
+ if projected.is_empty:
+ return projected
+ # if we happen to have intersected in only a point, return that
+ if projected.is_FiniteSet and len(projected) == 1:
+ # projected is a set of size 1, so unpack it in `a`
+ a, = projected
+ return a
+ # order args so projection is in the same direction as self
+ if self.direction.dot(projected.direction) < 0:
+ p1, p2 = projected.args
+ projected = projected.func(p2, p1)
+ return projected
+
+ raise GeometryError(
+ "Do not know how to project %s onto %s" % (other, self))
+
+ def random_point(self, seed=None):
+ """A random point on a LinearEntity.
+
+ Returns
+ =======
+
+ point : Point
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line, Ray, Segment
+ >>> p1, p2 = Point(0, 0), Point(5, 3)
+ >>> line = Line(p1, p2)
+ >>> r = line.random_point(seed=42) # seed value is optional
+ >>> r.n(3)
+ Point2D(-0.72, -0.432)
+ >>> r in line
+ True
+ >>> Ray(p1, p2).random_point(seed=42).n(3)
+ Point2D(0.72, 0.432)
+ >>> Segment(p1, p2).random_point(seed=42).n(3)
+ Point2D(3.2, 1.92)
+
+ """
+ if seed is not None:
+ rng = random.Random(seed)
+ else:
+ rng = random
+ pt = self.arbitrary_point(t)
+ if isinstance(self, Ray):
+ v = abs(rng.gauss(0, 1))
+ elif isinstance(self, Segment):
+ v = rng.random()
+ elif isinstance(self, Line):
+ v = rng.gauss(0, 1)
+ else:
+ raise NotImplementedError('unhandled line type')
+ return pt.subs(t, Rational(v))
+
+ def bisectors(self, other):
+ """Returns the perpendicular lines which pass through the intersections
+ of self and other that are in the same plane.
+
+ Parameters
+ ==========
+
+ line : Line3D
+
+ Returns
+ =======
+
+ list: two Line instances
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D
+ >>> r1 = Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0))
+ >>> r2 = Line3D(Point3D(0, 0, 0), Point3D(0, 1, 0))
+ >>> r1.bisectors(r2)
+ [Line3D(Point3D(0, 0, 0), Point3D(1, 1, 0)), Line3D(Point3D(0, 0, 0), Point3D(1, -1, 0))]
+
+ """
+ if not isinstance(other, LinearEntity):
+ raise GeometryError("Expecting LinearEntity, not %s" % other)
+
+ l1, l2 = self, other
+
+ # make sure dimensions match or else a warning will rise from
+ # intersection calculation
+ if l1.p1.ambient_dimension != l2.p1.ambient_dimension:
+ if isinstance(l1, Line2D):
+ l1, l2 = l2, l1
+ _, p1 = Point._normalize_dimension(l1.p1, l2.p1, on_morph='ignore')
+ _, p2 = Point._normalize_dimension(l1.p2, l2.p2, on_morph='ignore')
+ l2 = Line(p1, p2)
+
+ point = intersection(l1, l2)
+
+ # Three cases: Lines may intersect in a point, may be equal or may not intersect.
+ if not point:
+ raise GeometryError("The lines do not intersect")
+ else:
+ pt = point[0]
+ if isinstance(pt, Line):
+ # Intersection is a line because both lines are coincident
+ return [self]
+
+
+ d1 = l1.direction.unit
+ d2 = l2.direction.unit
+
+ bis1 = Line(pt, pt + d1 + d2)
+ bis2 = Line(pt, pt + d1 - d2)
+
+ return [bis1, bis2]
+
+
+class Line(LinearEntity):
+ """An infinite line in space.
+
+ A 2D line is declared with two distinct points, point and slope, or
+ an equation. A 3D line may be defined with a point and a direction ratio.
+
+ Parameters
+ ==========
+
+ p1 : Point
+ p2 : Point
+ slope : SymPy expression
+ direction_ratio : list
+ equation : equation of a line
+
+ Notes
+ =====
+
+ `Line` will automatically subclass to `Line2D` or `Line3D` based
+ on the dimension of `p1`. The `slope` argument is only relevant
+ for `Line2D` and the `direction_ratio` argument is only relevant
+ for `Line3D`.
+
+ The order of the points will define the direction of the line
+ which is used when calculating the angle between lines.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+ sympy.geometry.line.Line2D
+ sympy.geometry.line.Line3D
+
+ Examples
+ ========
+
+ >>> from sympy import Line, Segment, Point, Eq
+ >>> from sympy.abc import x, y, a, b
+
+ >>> L = Line(Point(2,3), Point(3,5))
+ >>> L
+ Line2D(Point2D(2, 3), Point2D(3, 5))
+ >>> L.points
+ (Point2D(2, 3), Point2D(3, 5))
+ >>> L.equation()
+ -2*x + y + 1
+ >>> L.coefficients
+ (-2, 1, 1)
+
+ Instantiate with keyword ``slope``:
+
+ >>> Line(Point(0, 0), slope=0)
+ Line2D(Point2D(0, 0), Point2D(1, 0))
+
+ Instantiate with another linear object
+
+ >>> s = Segment((0, 0), (0, 1))
+ >>> Line(s).equation()
+ x
+
+ The line corresponding to an equation in the for `ax + by + c = 0`,
+ can be entered:
+
+ >>> Line(3*x + y + 18)
+ Line2D(Point2D(0, -18), Point2D(1, -21))
+
+ If `x` or `y` has a different name, then they can be specified, too,
+ as a string (to match the name) or symbol:
+
+ >>> Line(Eq(3*a + b, -18), x='a', y=b)
+ Line2D(Point2D(0, -18), Point2D(1, -21))
+ """
+ def __new__(cls, *args, **kwargs):
+ if len(args) == 1 and isinstance(args[0], (Expr, Eq)):
+ missing = uniquely_named_symbol('?', args)
+ if not kwargs:
+ x = 'x'
+ y = 'y'
+ else:
+ x = kwargs.pop('x', missing)
+ y = kwargs.pop('y', missing)
+ if kwargs:
+ raise ValueError('expecting only x and y as keywords')
+
+ equation = args[0]
+ if isinstance(equation, Eq):
+ equation = equation.lhs - equation.rhs
+
+ def find_or_missing(x):
+ try:
+ return find(x, equation)
+ except ValueError:
+ return missing
+ x = find_or_missing(x)
+ y = find_or_missing(y)
+
+ a, b, c = linear_coeffs(equation, x, y)
+
+ if b:
+ return Line((0, -c/b), slope=-a/b)
+ if a:
+ return Line((-c/a, 0), slope=oo)
+
+ raise ValueError('not found in equation: %s' % (set('xy') - {x, y}))
+
+ else:
+ if len(args) > 0:
+ p1 = args[0]
+ if len(args) > 1:
+ p2 = args[1]
+ else:
+ p2 = None
+
+ if isinstance(p1, LinearEntity):
+ if p2:
+ raise ValueError('If p1 is a LinearEntity, p2 must be None.')
+ dim = len(p1.p1)
+ else:
+ p1 = Point(p1)
+ dim = len(p1)
+ if p2 is not None or isinstance(p2, Point) and p2.ambient_dimension != dim:
+ p2 = Point(p2)
+
+ if dim == 2:
+ return Line2D(p1, p2, **kwargs)
+ elif dim == 3:
+ return Line3D(p1, p2, **kwargs)
+ return LinearEntity.__new__(cls, p1, p2, **kwargs)
+
+ def contains(self, other):
+ """
+ Return True if `other` is on this Line, or False otherwise.
+
+ Examples
+ ========
+
+ >>> from sympy import Line,Point
+ >>> p1, p2 = Point(0, 1), Point(3, 4)
+ >>> l = Line(p1, p2)
+ >>> l.contains(p1)
+ True
+ >>> l.contains((0, 1))
+ True
+ >>> l.contains((0, 0))
+ False
+ >>> a = (0, 0, 0)
+ >>> b = (1, 1, 1)
+ >>> c = (2, 2, 2)
+ >>> l1 = Line(a, b)
+ >>> l2 = Line(b, a)
+ >>> l1 == l2
+ False
+ >>> l1 in l2
+ True
+
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if isinstance(other, Point):
+ return Point.is_collinear(other, self.p1, self.p2)
+ if isinstance(other, LinearEntity):
+ return Point.is_collinear(self.p1, self.p2, other.p1, other.p2)
+ return False
+
+ def distance(self, other):
+ """
+ Finds the shortest distance between a line and a point.
+
+ Raises
+ ======
+
+ NotImplementedError is raised if `other` is not a Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(1, 1)
+ >>> s = Line(p1, p2)
+ >>> s.distance(Point(-1, 1))
+ sqrt(2)
+ >>> s.distance((-1, 2))
+ 3*sqrt(2)/2
+ >>> p1, p2 = Point(0, 0, 0), Point(1, 1, 1)
+ >>> s = Line(p1, p2)
+ >>> s.distance(Point(-1, 1, 1))
+ 2*sqrt(6)/3
+ >>> s.distance((-1, 1, 1))
+ 2*sqrt(6)/3
+
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if self.contains(other):
+ return S.Zero
+ return self.perpendicular_segment(other).length
+
+ def equals(self, other):
+ """Returns True if self and other are the same mathematical entities"""
+ if not isinstance(other, Line):
+ return False
+ return Point.is_collinear(self.p1, other.p1, self.p2, other.p2)
+
+ def plot_interval(self, parameter='t'):
+ """The plot interval for the default geometric plot of line. Gives
+ values that will produce a line that is +/- 5 units long (where a
+ unit is the distance between the two points that define the line).
+
+ Parameters
+ ==========
+
+ parameter : str, optional
+ Default value is 't'.
+
+ Returns
+ =======
+
+ plot_interval : list (plot interval)
+ [parameter, lower_bound, upper_bound]
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(5, 3)
+ >>> l1 = Line(p1, p2)
+ >>> l1.plot_interval()
+ [t, -5, 5]
+
+ """
+ t = _symbol(parameter, real=True)
+ return [t, -5, 5]
+
+
+class Ray(LinearEntity):
+ """A Ray is a semi-line in the space with a source point and a direction.
+
+ Parameters
+ ==========
+
+ p1 : Point
+ The source of the Ray
+ p2 : Point or radian value
+ This point determines the direction in which the Ray propagates.
+ If given as an angle it is interpreted in radians with the positive
+ direction being ccw.
+
+ Attributes
+ ==========
+
+ source
+
+ See Also
+ ========
+
+ sympy.geometry.line.Ray2D
+ sympy.geometry.line.Ray3D
+ sympy.geometry.point.Point
+ sympy.geometry.line.Line
+
+ Notes
+ =====
+
+ `Ray` will automatically subclass to `Ray2D` or `Ray3D` based on the
+ dimension of `p1`.
+
+ Examples
+ ========
+
+ >>> from sympy import Ray, Point, pi
+ >>> r = Ray(Point(2, 3), Point(3, 5))
+ >>> r
+ Ray2D(Point2D(2, 3), Point2D(3, 5))
+ >>> r.points
+ (Point2D(2, 3), Point2D(3, 5))
+ >>> r.source
+ Point2D(2, 3)
+ >>> r.xdirection
+ oo
+ >>> r.ydirection
+ oo
+ >>> r.slope
+ 2
+ >>> Ray(Point(0, 0), angle=pi/4).slope
+ 1
+
+ """
+ def __new__(cls, p1, p2=None, **kwargs):
+ p1 = Point(p1)
+ if p2 is not None:
+ p1, p2 = Point._normalize_dimension(p1, Point(p2))
+ dim = len(p1)
+
+ if dim == 2:
+ return Ray2D(p1, p2, **kwargs)
+ elif dim == 3:
+ return Ray3D(p1, p2, **kwargs)
+ return LinearEntity.__new__(cls, p1, p2, **kwargs)
+
+ def _svg(self, scale_factor=1., fill_color="#66cc99"):
+ """Returns SVG path element for the LinearEntity.
+
+ Parameters
+ ==========
+
+ scale_factor : float
+ Multiplication factor for the SVG stroke-width. Default is 1.
+ fill_color : str, optional
+ Hex string for fill color. Default is "#66cc99".
+ """
+ verts = (N(self.p1), N(self.p2))
+ coords = ["{},{}".format(p.x, p.y) for p in verts]
+ path = "M {} L {}".format(coords[0], " L ".join(coords[1:]))
+
+ return (
+ ''
+ ).format(2.*scale_factor, path, fill_color)
+
+ def contains(self, other):
+ """
+ Is other GeometryEntity contained in this Ray?
+
+ Examples
+ ========
+
+ >>> from sympy import Ray,Point,Segment
+ >>> p1, p2 = Point(0, 0), Point(4, 4)
+ >>> r = Ray(p1, p2)
+ >>> r.contains(p1)
+ True
+ >>> r.contains((1, 1))
+ True
+ >>> r.contains((1, 3))
+ False
+ >>> s = Segment((1, 1), (2, 2))
+ >>> r.contains(s)
+ True
+ >>> s = Segment((1, 2), (2, 5))
+ >>> r.contains(s)
+ False
+ >>> r1 = Ray((2, 2), (3, 3))
+ >>> r.contains(r1)
+ True
+ >>> r1 = Ray((2, 2), (3, 5))
+ >>> r.contains(r1)
+ False
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if isinstance(other, Point):
+ if Point.is_collinear(self.p1, self.p2, other):
+ # if we're in the direction of the ray, our
+ # direction vector dot the ray's direction vector
+ # should be non-negative
+ return bool((self.p2 - self.p1).dot(other - self.p1) >= S.Zero)
+ return False
+ elif isinstance(other, Ray):
+ if Point.is_collinear(self.p1, self.p2, other.p1, other.p2):
+ return bool((self.p2 - self.p1).dot(other.p2 - other.p1) > S.Zero)
+ return False
+ elif isinstance(other, Segment):
+ return other.p1 in self and other.p2 in self
+
+ # No other known entity can be contained in a Ray
+ return False
+
+ def distance(self, other):
+ """
+ Finds the shortest distance between the ray and a point.
+
+ Raises
+ ======
+
+ NotImplementedError is raised if `other` is not a Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ray
+ >>> p1, p2 = Point(0, 0), Point(1, 1)
+ >>> s = Ray(p1, p2)
+ >>> s.distance(Point(-1, -1))
+ sqrt(2)
+ >>> s.distance((-1, 2))
+ 3*sqrt(2)/2
+ >>> p1, p2 = Point(0, 0, 0), Point(1, 1, 2)
+ >>> s = Ray(p1, p2)
+ >>> s
+ Ray3D(Point3D(0, 0, 0), Point3D(1, 1, 2))
+ >>> s.distance(Point(-1, -1, 2))
+ 4*sqrt(3)/3
+ >>> s.distance((-1, -1, 2))
+ 4*sqrt(3)/3
+
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if self.contains(other):
+ return S.Zero
+
+ proj = Line(self.p1, self.p2).projection(other)
+ if self.contains(proj):
+ return abs(other - proj)
+ else:
+ return abs(other - self.source)
+
+ def equals(self, other):
+ """Returns True if self and other are the same mathematical entities"""
+ if not isinstance(other, Ray):
+ return False
+ return self.source == other.source and other.p2 in self
+
+ def plot_interval(self, parameter='t'):
+ """The plot interval for the default geometric plot of the Ray. Gives
+ values that will produce a ray that is 10 units long (where a unit is
+ the distance between the two points that define the ray).
+
+ Parameters
+ ==========
+
+ parameter : str, optional
+ Default value is 't'.
+
+ Returns
+ =======
+
+ plot_interval : list
+ [parameter, lower_bound, upper_bound]
+
+ Examples
+ ========
+
+ >>> from sympy import Ray, pi
+ >>> r = Ray((0, 0), angle=pi/4)
+ >>> r.plot_interval()
+ [t, 0, 10]
+
+ """
+ t = _symbol(parameter, real=True)
+ return [t, 0, 10]
+
+ @property
+ def source(self):
+ """The point from which the ray emanates.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ray
+ >>> p1, p2 = Point(0, 0), Point(4, 1)
+ >>> r1 = Ray(p1, p2)
+ >>> r1.source
+ Point2D(0, 0)
+ >>> p1, p2 = Point(0, 0, 0), Point(4, 1, 5)
+ >>> r1 = Ray(p2, p1)
+ >>> r1.source
+ Point3D(4, 1, 5)
+
+ """
+ return self.p1
+
+
+class Segment(LinearEntity):
+ """A line segment in space.
+
+ Parameters
+ ==========
+
+ p1 : Point
+ p2 : Point
+
+ Attributes
+ ==========
+
+ length : number or SymPy expression
+ midpoint : Point
+
+ See Also
+ ========
+
+ sympy.geometry.line.Segment2D
+ sympy.geometry.line.Segment3D
+ sympy.geometry.point.Point
+ sympy.geometry.line.Line
+
+ Notes
+ =====
+
+ If 2D or 3D points are used to define `Segment`, it will
+ be automatically subclassed to `Segment2D` or `Segment3D`.
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment
+ >>> Segment((1, 0), (1, 1)) # tuples are interpreted as pts
+ Segment2D(Point2D(1, 0), Point2D(1, 1))
+ >>> s = Segment(Point(4, 3), Point(1, 1))
+ >>> s.points
+ (Point2D(4, 3), Point2D(1, 1))
+ >>> s.slope
+ 2/3
+ >>> s.length
+ sqrt(13)
+ >>> s.midpoint
+ Point2D(5/2, 2)
+ >>> Segment((1, 0, 0), (1, 1, 1)) # tuples are interpreted as pts
+ Segment3D(Point3D(1, 0, 0), Point3D(1, 1, 1))
+ >>> s = Segment(Point(4, 3, 9), Point(1, 1, 7)); s
+ Segment3D(Point3D(4, 3, 9), Point3D(1, 1, 7))
+ >>> s.points
+ (Point3D(4, 3, 9), Point3D(1, 1, 7))
+ >>> s.length
+ sqrt(17)
+ >>> s.midpoint
+ Point3D(5/2, 2, 8)
+
+ """
+ def __new__(cls, p1, p2, **kwargs):
+ p1, p2 = Point._normalize_dimension(Point(p1), Point(p2))
+ dim = len(p1)
+
+ if dim == 2:
+ return Segment2D(p1, p2, **kwargs)
+ elif dim == 3:
+ return Segment3D(p1, p2, **kwargs)
+ return LinearEntity.__new__(cls, p1, p2, **kwargs)
+
+ def contains(self, other):
+ """
+ Is the other GeometryEntity contained within this Segment?
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment
+ >>> p1, p2 = Point(0, 1), Point(3, 4)
+ >>> s = Segment(p1, p2)
+ >>> s2 = Segment(p2, p1)
+ >>> s.contains(s2)
+ True
+ >>> from sympy import Point3D, Segment3D
+ >>> p1, p2 = Point3D(0, 1, 1), Point3D(3, 4, 5)
+ >>> s = Segment3D(p1, p2)
+ >>> s2 = Segment3D(p2, p1)
+ >>> s.contains(s2)
+ True
+ >>> s.contains((p1 + p2)/2)
+ True
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if isinstance(other, Point):
+ if Point.is_collinear(other, self.p1, self.p2):
+ if isinstance(self, Segment2D):
+ # if it is collinear and is in the bounding box of the
+ # segment then it must be on the segment
+ vert = (1/self.slope).equals(0)
+ if vert is False:
+ isin = (self.p1.x - other.x)*(self.p2.x - other.x) <= 0
+ if isin in (True, False):
+ return isin
+ if vert is True:
+ isin = (self.p1.y - other.y)*(self.p2.y - other.y) <= 0
+ if isin in (True, False):
+ return isin
+ # use the triangle inequality
+ d1, d2 = other - self.p1, other - self.p2
+ d = self.p2 - self.p1
+ # without the call to simplify, SymPy cannot tell that an expression
+ # like (a+b)*(a/2+b/2) is always non-negative. If it cannot be
+ # determined, raise an Undecidable error
+ try:
+ # the triangle inequality says that |d1|+|d2| >= |d| and is strict
+ # only if other lies in the line segment
+ return bool(simplify(Eq(abs(d1) + abs(d2) - abs(d), 0)))
+ except TypeError:
+ raise Undecidable("Cannot determine if {} is in {}".format(other, self))
+ if isinstance(other, Segment):
+ return other.p1 in self and other.p2 in self
+
+ return False
+
+ def equals(self, other):
+ """Returns True if self and other are the same mathematical entities"""
+ return isinstance(other, self.func) and list(
+ ordered(self.args)) == list(ordered(other.args))
+
+ def distance(self, other):
+ """
+ Finds the shortest distance between a line segment and a point.
+
+ Raises
+ ======
+
+ NotImplementedError is raised if `other` is not a Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment
+ >>> p1, p2 = Point(0, 1), Point(3, 4)
+ >>> s = Segment(p1, p2)
+ >>> s.distance(Point(10, 15))
+ sqrt(170)
+ >>> s.distance((0, 12))
+ sqrt(73)
+ >>> from sympy import Point3D, Segment3D
+ >>> p1, p2 = Point3D(0, 0, 3), Point3D(1, 1, 4)
+ >>> s = Segment3D(p1, p2)
+ >>> s.distance(Point3D(10, 15, 12))
+ sqrt(341)
+ >>> s.distance((10, 15, 12))
+ sqrt(341)
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if isinstance(other, Point):
+ vp1 = other - self.p1
+ vp2 = other - self.p2
+
+ dot_prod_sign_1 = self.direction.dot(vp1) >= 0
+ dot_prod_sign_2 = self.direction.dot(vp2) <= 0
+ if dot_prod_sign_1 and dot_prod_sign_2:
+ return Line(self.p1, self.p2).distance(other)
+ if dot_prod_sign_1 and not dot_prod_sign_2:
+ return abs(vp2)
+ if not dot_prod_sign_1 and dot_prod_sign_2:
+ return abs(vp1)
+ raise NotImplementedError()
+
+ @property
+ def length(self):
+ """The length of the line segment.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point.distance
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment
+ >>> p1, p2 = Point(0, 0), Point(4, 3)
+ >>> s1 = Segment(p1, p2)
+ >>> s1.length
+ 5
+ >>> from sympy import Point3D, Segment3D
+ >>> p1, p2 = Point3D(0, 0, 0), Point3D(4, 3, 3)
+ >>> s1 = Segment3D(p1, p2)
+ >>> s1.length
+ sqrt(34)
+
+ """
+ return Point.distance(self.p1, self.p2)
+
+ @property
+ def midpoint(self):
+ """The midpoint of the line segment.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point.midpoint
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment
+ >>> p1, p2 = Point(0, 0), Point(4, 3)
+ >>> s1 = Segment(p1, p2)
+ >>> s1.midpoint
+ Point2D(2, 3/2)
+ >>> from sympy import Point3D, Segment3D
+ >>> p1, p2 = Point3D(0, 0, 0), Point3D(4, 3, 3)
+ >>> s1 = Segment3D(p1, p2)
+ >>> s1.midpoint
+ Point3D(2, 3/2, 3/2)
+
+ """
+ return Point.midpoint(self.p1, self.p2)
+
+ def perpendicular_bisector(self, p=None):
+ """The perpendicular bisector of this segment.
+
+ If no point is specified or the point specified is not on the
+ bisector then the bisector is returned as a Line. Otherwise a
+ Segment is returned that joins the point specified and the
+ intersection of the bisector and the segment.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ bisector : Line or Segment
+
+ See Also
+ ========
+
+ LinearEntity.perpendicular_segment
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment
+ >>> p1, p2, p3 = Point(0, 0), Point(6, 6), Point(5, 1)
+ >>> s1 = Segment(p1, p2)
+ >>> s1.perpendicular_bisector()
+ Line2D(Point2D(3, 3), Point2D(-3, 9))
+
+ >>> s1.perpendicular_bisector(p3)
+ Segment2D(Point2D(5, 1), Point2D(3, 3))
+
+ """
+ l = self.perpendicular_line(self.midpoint)
+ if p is not None:
+ p2 = Point(p, dim=self.ambient_dimension)
+ if p2 in l:
+ return Segment(p2, self.midpoint)
+ return l
+
+ def plot_interval(self, parameter='t'):
+ """The plot interval for the default geometric plot of the Segment gives
+ values that will produce the full segment in a plot.
+
+ Parameters
+ ==========
+
+ parameter : str, optional
+ Default value is 't'.
+
+ Returns
+ =======
+
+ plot_interval : list
+ [parameter, lower_bound, upper_bound]
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment
+ >>> p1, p2 = Point(0, 0), Point(5, 3)
+ >>> s1 = Segment(p1, p2)
+ >>> s1.plot_interval()
+ [t, 0, 1]
+
+ """
+ t = _symbol(parameter, real=True)
+ return [t, 0, 1]
+
+
+class LinearEntity2D(LinearEntity):
+ """A base class for all linear entities (line, ray and segment)
+ in a 2-dimensional Euclidean space.
+
+ Attributes
+ ==========
+
+ p1
+ p2
+ coefficients
+ slope
+ points
+
+ Notes
+ =====
+
+ This is an abstract class and is not meant to be instantiated.
+
+ See Also
+ ========
+
+ sympy.geometry.entity.GeometryEntity
+
+ """
+ @property
+ def bounds(self):
+ """Return a tuple (xmin, ymin, xmax, ymax) representing the bounding
+ rectangle for the geometric figure.
+
+ """
+ verts = self.points
+ xs = [p.x for p in verts]
+ ys = [p.y for p in verts]
+ return (min(xs), min(ys), max(xs), max(ys))
+
+ def perpendicular_line(self, p):
+ """Create a new Line perpendicular to this linear entity which passes
+ through the point `p`.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ line : Line
+
+ See Also
+ ========
+
+ sympy.geometry.line.LinearEntity.is_perpendicular, perpendicular_segment
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2, p3 = Point(0, 0), Point(2, 3), Point(-2, 2)
+ >>> L = Line(p1, p2)
+ >>> P = L.perpendicular_line(p3); P
+ Line2D(Point2D(-2, 2), Point2D(-5, 4))
+ >>> L.is_perpendicular(P)
+ True
+
+ In 2D, the first point of the perpendicular line is the
+ point through which was required to pass; the second
+ point is arbitrarily chosen. To get a line that explicitly
+ uses a point in the line, create a line from the perpendicular
+ segment from the line to the point:
+
+ >>> Line(L.perpendicular_segment(p3))
+ Line2D(Point2D(-2, 2), Point2D(4/13, 6/13))
+ """
+ p = Point(p, dim=self.ambient_dimension)
+ # any two lines in R^2 intersect, so blindly making
+ # a line through p in an orthogonal direction will work
+ # and is faster than finding the projection point as in 3D
+ return Line(p, p + self.direction.orthogonal_direction)
+
+ @property
+ def slope(self):
+ """The slope of this linear entity, or infinity if vertical.
+
+ Returns
+ =======
+
+ slope : number or SymPy expression
+
+ See Also
+ ========
+
+ coefficients
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(0, 0), Point(3, 5)
+ >>> l1 = Line(p1, p2)
+ >>> l1.slope
+ 5/3
+
+ >>> p3 = Point(0, 4)
+ >>> l2 = Line(p1, p3)
+ >>> l2.slope
+ oo
+
+ """
+ d1, d2 = (self.p1 - self.p2).args
+ if d1 == 0:
+ return S.Infinity
+ return simplify(d2/d1)
+
+
+class Line2D(LinearEntity2D, Line):
+ """An infinite line in space 2D.
+
+ A line is declared with two distinct points or a point and slope
+ as defined using keyword `slope`.
+
+ Parameters
+ ==========
+
+ p1 : Point
+ pt : Point
+ slope : SymPy expression
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Line, Segment, Point
+ >>> L = Line(Point(2,3), Point(3,5))
+ >>> L
+ Line2D(Point2D(2, 3), Point2D(3, 5))
+ >>> L.points
+ (Point2D(2, 3), Point2D(3, 5))
+ >>> L.equation()
+ -2*x + y + 1
+ >>> L.coefficients
+ (-2, 1, 1)
+
+ Instantiate with keyword ``slope``:
+
+ >>> Line(Point(0, 0), slope=0)
+ Line2D(Point2D(0, 0), Point2D(1, 0))
+
+ Instantiate with another linear object
+
+ >>> s = Segment((0, 0), (0, 1))
+ >>> Line(s).equation()
+ x
+ """
+ def __new__(cls, p1, pt=None, slope=None, **kwargs):
+ if isinstance(p1, LinearEntity):
+ if pt is not None:
+ raise ValueError('When p1 is a LinearEntity, pt should be None')
+ p1, pt = Point._normalize_dimension(*p1.args, dim=2)
+ else:
+ p1 = Point(p1, dim=2)
+ if pt is not None and slope is None:
+ try:
+ p2 = Point(pt, dim=2)
+ except (NotImplementedError, TypeError, ValueError):
+ raise ValueError(filldedent('''
+ The 2nd argument was not a valid Point.
+ If it was a slope, enter it with keyword "slope".
+ '''))
+ elif slope is not None and pt is None:
+ slope = sympify(slope)
+ if slope.is_finite is False:
+ # when infinite slope, don't change x
+ dx = 0
+ dy = 1
+ else:
+ # go over 1 up slope
+ dx = 1
+ dy = slope
+ # XXX avoiding simplification by adding to coords directly
+ p2 = Point(p1.x + dx, p1.y + dy, evaluate=False)
+ else:
+ raise ValueError('A 2nd Point or keyword "slope" must be used.')
+ return LinearEntity2D.__new__(cls, p1, p2, **kwargs)
+
+ def _svg(self, scale_factor=1., fill_color="#66cc99"):
+ """Returns SVG path element for the LinearEntity.
+
+ Parameters
+ ==========
+
+ scale_factor : float
+ Multiplication factor for the SVG stroke-width. Default is 1.
+ fill_color : str, optional
+ Hex string for fill color. Default is "#66cc99".
+ """
+ verts = (N(self.p1), N(self.p2))
+ coords = ["{},{}".format(p.x, p.y) for p in verts]
+ path = "M {} L {}".format(coords[0], " L ".join(coords[1:]))
+
+ return (
+ ''
+ ).format(2.*scale_factor, path, fill_color)
+
+ @property
+ def coefficients(self):
+ """The coefficients (`a`, `b`, `c`) for `ax + by + c = 0`.
+
+ See Also
+ ========
+
+ sympy.geometry.line.Line2D.equation
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> from sympy.abc import x, y
+ >>> p1, p2 = Point(0, 0), Point(5, 3)
+ >>> l = Line(p1, p2)
+ >>> l.coefficients
+ (-3, 5, 0)
+
+ >>> p3 = Point(x, y)
+ >>> l2 = Line(p1, p3)
+ >>> l2.coefficients
+ (-y, x, 0)
+
+ """
+ p1, p2 = self.points
+ if p1.x == p2.x:
+ return (S.One, S.Zero, -p1.x)
+ elif p1.y == p2.y:
+ return (S.Zero, S.One, -p1.y)
+ return tuple([simplify(i) for i in
+ (self.p1.y - self.p2.y,
+ self.p2.x - self.p1.x,
+ self.p1.x*self.p2.y - self.p1.y*self.p2.x)])
+
+ def equation(self, x='x', y='y'):
+ """The equation of the line: ax + by + c.
+
+ Parameters
+ ==========
+
+ x : str, optional
+ The name to use for the x-axis, default value is 'x'.
+ y : str, optional
+ The name to use for the y-axis, default value is 'y'.
+
+ Returns
+ =======
+
+ equation : SymPy expression
+
+ See Also
+ ========
+
+ sympy.geometry.line.Line2D.coefficients
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(1, 0), Point(5, 3)
+ >>> l1 = Line(p1, p2)
+ >>> l1.equation()
+ -3*x + 4*y + 3
+
+ """
+ x = _symbol(x, real=True)
+ y = _symbol(y, real=True)
+ p1, p2 = self.points
+ if p1.x == p2.x:
+ return x - p1.x
+ elif p1.y == p2.y:
+ return y - p1.y
+
+ a, b, c = self.coefficients
+ return a*x + b*y + c
+
+
+class Ray2D(LinearEntity2D, Ray):
+ """
+ A Ray is a semi-line in the space with a source point and a direction.
+
+ Parameters
+ ==========
+
+ p1 : Point
+ The source of the Ray
+ p2 : Point or radian value
+ This point determines the direction in which the Ray propagates.
+ If given as an angle it is interpreted in radians with the positive
+ direction being ccw.
+
+ Attributes
+ ==========
+
+ source
+ xdirection
+ ydirection
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, Line
+
+ Examples
+ ========
+
+ >>> from sympy import Point, pi, Ray
+ >>> r = Ray(Point(2, 3), Point(3, 5))
+ >>> r
+ Ray2D(Point2D(2, 3), Point2D(3, 5))
+ >>> r.points
+ (Point2D(2, 3), Point2D(3, 5))
+ >>> r.source
+ Point2D(2, 3)
+ >>> r.xdirection
+ oo
+ >>> r.ydirection
+ oo
+ >>> r.slope
+ 2
+ >>> Ray(Point(0, 0), angle=pi/4).slope
+ 1
+
+ """
+ def __new__(cls, p1, pt=None, angle=None, **kwargs):
+ p1 = Point(p1, dim=2)
+ if pt is not None and angle is None:
+ try:
+ p2 = Point(pt, dim=2)
+ except (NotImplementedError, TypeError, ValueError):
+ raise ValueError(filldedent('''
+ The 2nd argument was not a valid Point; if
+ it was meant to be an angle it should be
+ given with keyword "angle".'''))
+ if p1 == p2:
+ raise ValueError('A Ray requires two distinct points.')
+ elif angle is not None and pt is None:
+ # we need to know if the angle is an odd multiple of pi/2
+ angle = sympify(angle)
+ c = _pi_coeff(angle)
+ p2 = None
+ if c is not None:
+ if c.is_Rational:
+ if c.q == 2:
+ if c.p == 1:
+ p2 = p1 + Point(0, 1)
+ elif c.p == 3:
+ p2 = p1 + Point(0, -1)
+ elif c.q == 1:
+ if c.p == 0:
+ p2 = p1 + Point(1, 0)
+ elif c.p == 1:
+ p2 = p1 + Point(-1, 0)
+ if p2 is None:
+ c *= S.Pi
+ else:
+ c = angle % (2*S.Pi)
+ if not p2:
+ m = 2*c/S.Pi
+ left = And(1 < m, m < 3) # is it in quadrant 2 or 3?
+ x = Piecewise((-1, left), (Piecewise((0, Eq(m % 1, 0)), (1, True)), True))
+ y = Piecewise((-tan(c), left), (Piecewise((1, Eq(m, 1)), (-1, Eq(m, 3)), (tan(c), True)), True))
+ p2 = p1 + Point(x, y)
+ else:
+ raise ValueError('A 2nd point or keyword "angle" must be used.')
+
+ return LinearEntity2D.__new__(cls, p1, p2, **kwargs)
+
+ @property
+ def xdirection(self):
+ """The x direction of the ray.
+
+ Positive infinity if the ray points in the positive x direction,
+ negative infinity if the ray points in the negative x direction,
+ or 0 if the ray is vertical.
+
+ See Also
+ ========
+
+ ydirection
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ray
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(0, -1)
+ >>> r1, r2 = Ray(p1, p2), Ray(p1, p3)
+ >>> r1.xdirection
+ oo
+ >>> r2.xdirection
+ 0
+
+ """
+ if self.p1.x < self.p2.x:
+ return S.Infinity
+ elif self.p1.x == self.p2.x:
+ return S.Zero
+ else:
+ return S.NegativeInfinity
+
+ @property
+ def ydirection(self):
+ """The y direction of the ray.
+
+ Positive infinity if the ray points in the positive y direction,
+ negative infinity if the ray points in the negative y direction,
+ or 0 if the ray is horizontal.
+
+ See Also
+ ========
+
+ xdirection
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Ray
+ >>> p1, p2, p3 = Point(0, 0), Point(-1, -1), Point(-1, 0)
+ >>> r1, r2 = Ray(p1, p2), Ray(p1, p3)
+ >>> r1.ydirection
+ -oo
+ >>> r2.ydirection
+ 0
+
+ """
+ if self.p1.y < self.p2.y:
+ return S.Infinity
+ elif self.p1.y == self.p2.y:
+ return S.Zero
+ else:
+ return S.NegativeInfinity
+
+ def closing_angle(r1, r2):
+ """Return the angle by which r2 must be rotated so it faces the same
+ direction as r1.
+
+ Parameters
+ ==========
+
+ r1 : Ray2D
+ r2 : Ray2D
+
+ Returns
+ =======
+
+ angle : angle in radians (ccw angle is positive)
+
+ See Also
+ ========
+
+ LinearEntity.angle_between
+
+ Examples
+ ========
+
+ >>> from sympy import Ray, pi
+ >>> r1 = Ray((0, 0), (1, 0))
+ >>> r2 = r1.rotate(-pi/2)
+ >>> angle = r1.closing_angle(r2); angle
+ pi/2
+ >>> r2.rotate(angle).direction.unit == r1.direction.unit
+ True
+ >>> r2.closing_angle(r1)
+ -pi/2
+ """
+ if not all(isinstance(r, Ray2D) for r in (r1, r2)):
+ # although the direction property is defined for
+ # all linear entities, only the Ray is truly a
+ # directed object
+ raise TypeError('Both arguments must be Ray2D objects.')
+
+ a1 = atan2(*list(reversed(r1.direction.args)))
+ a2 = atan2(*list(reversed(r2.direction.args)))
+ if a1*a2 < 0:
+ a1 = 2*S.Pi + a1 if a1 < 0 else a1
+ a2 = 2*S.Pi + a2 if a2 < 0 else a2
+ return a1 - a2
+
+
+class Segment2D(LinearEntity2D, Segment):
+ """A line segment in 2D space.
+
+ Parameters
+ ==========
+
+ p1 : Point
+ p2 : Point
+
+ Attributes
+ ==========
+
+ length : number or SymPy expression
+ midpoint : Point
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, Line
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment
+ >>> Segment((1, 0), (1, 1)) # tuples are interpreted as pts
+ Segment2D(Point2D(1, 0), Point2D(1, 1))
+ >>> s = Segment(Point(4, 3), Point(1, 1)); s
+ Segment2D(Point2D(4, 3), Point2D(1, 1))
+ >>> s.points
+ (Point2D(4, 3), Point2D(1, 1))
+ >>> s.slope
+ 2/3
+ >>> s.length
+ sqrt(13)
+ >>> s.midpoint
+ Point2D(5/2, 2)
+
+ """
+ def __new__(cls, p1, p2, **kwargs):
+ p1 = Point(p1, dim=2)
+ p2 = Point(p2, dim=2)
+
+ if p1 == p2:
+ return p1
+
+ return LinearEntity2D.__new__(cls, p1, p2, **kwargs)
+
+ def _svg(self, scale_factor=1., fill_color="#66cc99"):
+ """Returns SVG path element for the LinearEntity.
+
+ Parameters
+ ==========
+
+ scale_factor : float
+ Multiplication factor for the SVG stroke-width. Default is 1.
+ fill_color : str, optional
+ Hex string for fill color. Default is "#66cc99".
+ """
+ verts = (N(self.p1), N(self.p2))
+ coords = ["{},{}".format(p.x, p.y) for p in verts]
+ path = "M {} L {}".format(coords[0], " L ".join(coords[1:]))
+ return (
+ ''
+ ).format(2.*scale_factor, path, fill_color)
+
+
+class LinearEntity3D(LinearEntity):
+ """An base class for all linear entities (line, ray and segment)
+ in a 3-dimensional Euclidean space.
+
+ Attributes
+ ==========
+
+ p1
+ p2
+ direction_ratio
+ direction_cosine
+ points
+
+ Notes
+ =====
+
+ This is a base class and is not meant to be instantiated.
+ """
+ def __new__(cls, p1, p2, **kwargs):
+ p1 = Point3D(p1, dim=3)
+ p2 = Point3D(p2, dim=3)
+ if p1 == p2:
+ # if it makes sense to return a Point, handle in subclass
+ raise ValueError(
+ "%s.__new__ requires two unique Points." % cls.__name__)
+
+ return GeometryEntity.__new__(cls, p1, p2, **kwargs)
+
+ ambient_dimension = 3
+
+ @property
+ def direction_ratio(self):
+ """The direction ratio of a given line in 3D.
+
+ See Also
+ ========
+
+ sympy.geometry.line.Line3D.equation
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2 = Point3D(0, 0, 0), Point3D(5, 3, 1)
+ >>> l = Line3D(p1, p2)
+ >>> l.direction_ratio
+ [5, 3, 1]
+ """
+ p1, p2 = self.points
+ return p1.direction_ratio(p2)
+
+ @property
+ def direction_cosine(self):
+ """The normalized direction ratio of a given line in 3D.
+
+ See Also
+ ========
+
+ sympy.geometry.line.Line3D.equation
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D
+ >>> p1, p2 = Point3D(0, 0, 0), Point3D(5, 3, 1)
+ >>> l = Line3D(p1, p2)
+ >>> l.direction_cosine
+ [sqrt(35)/7, 3*sqrt(35)/35, sqrt(35)/35]
+ >>> sum(i**2 for i in _)
+ 1
+ """
+ p1, p2 = self.points
+ return p1.direction_cosine(p2)
+
+
+class Line3D(LinearEntity3D, Line):
+ """An infinite 3D line in space.
+
+ A line is declared with two distinct points or a point and direction_ratio
+ as defined using keyword `direction_ratio`.
+
+ Parameters
+ ==========
+
+ p1 : Point3D
+ pt : Point3D
+ direction_ratio : list
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point3D
+ sympy.geometry.line.Line
+ sympy.geometry.line.Line2D
+
+ Examples
+ ========
+
+ >>> from sympy import Line3D, Point3D
+ >>> L = Line3D(Point3D(2, 3, 4), Point3D(3, 5, 1))
+ >>> L
+ Line3D(Point3D(2, 3, 4), Point3D(3, 5, 1))
+ >>> L.points
+ (Point3D(2, 3, 4), Point3D(3, 5, 1))
+ """
+ def __new__(cls, p1, pt=None, direction_ratio=(), **kwargs):
+ if isinstance(p1, LinearEntity3D):
+ if pt is not None:
+ raise ValueError('if p1 is a LinearEntity, pt must be None.')
+ p1, pt = p1.args
+ else:
+ p1 = Point(p1, dim=3)
+ if pt is not None and len(direction_ratio) == 0:
+ pt = Point(pt, dim=3)
+ elif len(direction_ratio) == 3 and pt is None:
+ pt = Point3D(p1.x + direction_ratio[0], p1.y + direction_ratio[1],
+ p1.z + direction_ratio[2])
+ else:
+ raise ValueError('A 2nd Point or keyword "direction_ratio" must '
+ 'be used.')
+
+ return LinearEntity3D.__new__(cls, p1, pt, **kwargs)
+
+ def equation(self, x='x', y='y', z='z'):
+ """Return the equations that define the line in 3D.
+
+ Parameters
+ ==========
+
+ x : str, optional
+ The name to use for the x-axis, default value is 'x'.
+ y : str, optional
+ The name to use for the y-axis, default value is 'y'.
+ z : str, optional
+ The name to use for the z-axis, default value is 'z'.
+
+ Returns
+ =======
+
+ equation : Tuple of simultaneous equations
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D, solve
+ >>> from sympy.abc import x, y, z
+ >>> p1, p2 = Point3D(1, 0, 0), Point3D(5, 3, 0)
+ >>> l1 = Line3D(p1, p2)
+ >>> eq = l1.equation(x, y, z); eq
+ (-3*x + 4*y + 3, z)
+ >>> solve(eq.subs(z, 0), (x, y, z))
+ {x: 4*y/3 + 1}
+ """
+ x, y, z, k = [_symbol(i, real=True) for i in (x, y, z, 'k')]
+ p1, p2 = self.points
+ d1, d2, d3 = p1.direction_ratio(p2)
+ x1, y1, z1 = p1
+ eqs = [-d1*k + x - x1, -d2*k + y - y1, -d3*k + z - z1]
+ # eliminate k from equations by solving first eq with k for k
+ for i, e in enumerate(eqs):
+ if e.has(k):
+ kk = solve(eqs[i], k)[0]
+ eqs.pop(i)
+ break
+ return Tuple(*[i.subs(k, kk).as_numer_denom()[0] for i in eqs])
+
+ def distance(self, other):
+ """
+ Finds the shortest distance between a line and another object.
+
+ Parameters
+ ==========
+
+ Point3D, Line3D, Plane, tuple, list
+
+ Returns
+ =======
+
+ distance
+
+ Notes
+ =====
+
+ This method accepts only 3D entities as it's parameter
+
+ Tuples and lists are converted to Point3D and therefore must be of
+ length 3, 2 or 1.
+
+ NotImplementedError is raised if `other` is not an instance of one
+ of the specified classes: Point3D, Line3D, or Plane.
+
+ Examples
+ ========
+
+ >>> from sympy.geometry import Line3D
+ >>> l1 = Line3D((0, 0, 0), (0, 0, 1))
+ >>> l2 = Line3D((0, 1, 0), (1, 1, 1))
+ >>> l1.distance(l2)
+ 1
+
+ The computed distance may be symbolic, too:
+
+ >>> from sympy.abc import x, y
+ >>> l1 = Line3D((0, 0, 0), (0, 0, 1))
+ >>> l2 = Line3D((0, x, 0), (y, x, 1))
+ >>> l1.distance(l2)
+ Abs(x*y)/Abs(sqrt(y**2))
+
+ """
+
+ from .plane import Plane # Avoid circular import
+
+ if isinstance(other, (tuple, list)):
+ try:
+ other = Point3D(other)
+ except ValueError:
+ pass
+
+ if isinstance(other, Point3D):
+ return super().distance(other)
+
+ if isinstance(other, Line3D):
+ if self == other:
+ return S.Zero
+ if self.is_parallel(other):
+ return super().distance(other.p1)
+
+ # Skew lines
+ self_direction = Matrix(self.direction_ratio)
+ other_direction = Matrix(other.direction_ratio)
+ normal = self_direction.cross(other_direction)
+ plane_through_self = Plane(p1=self.p1, normal_vector=normal)
+ return other.p1.distance(plane_through_self)
+
+ if isinstance(other, Plane):
+ return other.distance(self)
+
+ msg = f"{other} has type {type(other)}, which is unsupported"
+ raise NotImplementedError(msg)
+
+
+class Ray3D(LinearEntity3D, Ray):
+ """
+ A Ray is a semi-line in the space with a source point and a direction.
+
+ Parameters
+ ==========
+
+ p1 : Point3D
+ The source of the Ray
+ p2 : Point or a direction vector
+ direction_ratio: Determines the direction in which the Ray propagates.
+
+
+ Attributes
+ ==========
+
+ source
+ xdirection
+ ydirection
+ zdirection
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point3D, Line3D
+
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Ray3D
+ >>> r = Ray3D(Point3D(2, 3, 4), Point3D(3, 5, 0))
+ >>> r
+ Ray3D(Point3D(2, 3, 4), Point3D(3, 5, 0))
+ >>> r.points
+ (Point3D(2, 3, 4), Point3D(3, 5, 0))
+ >>> r.source
+ Point3D(2, 3, 4)
+ >>> r.xdirection
+ oo
+ >>> r.ydirection
+ oo
+ >>> r.direction_ratio
+ [1, 2, -4]
+
+ """
+ def __new__(cls, p1, pt=None, direction_ratio=(), **kwargs):
+ if isinstance(p1, LinearEntity3D):
+ if pt is not None:
+ raise ValueError('If p1 is a LinearEntity, pt must be None')
+ p1, pt = p1.args
+ else:
+ p1 = Point(p1, dim=3)
+ if pt is not None and len(direction_ratio) == 0:
+ pt = Point(pt, dim=3)
+ elif len(direction_ratio) == 3 and pt is None:
+ pt = Point3D(p1.x + direction_ratio[0], p1.y + direction_ratio[1],
+ p1.z + direction_ratio[2])
+ else:
+ raise ValueError(filldedent('''
+ A 2nd Point or keyword "direction_ratio" must be used.
+ '''))
+
+ return LinearEntity3D.__new__(cls, p1, pt, **kwargs)
+
+ @property
+ def xdirection(self):
+ """The x direction of the ray.
+
+ Positive infinity if the ray points in the positive x direction,
+ negative infinity if the ray points in the negative x direction,
+ or 0 if the ray is vertical.
+
+ See Also
+ ========
+
+ ydirection
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Ray3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(0, -1, 0)
+ >>> r1, r2 = Ray3D(p1, p2), Ray3D(p1, p3)
+ >>> r1.xdirection
+ oo
+ >>> r2.xdirection
+ 0
+
+ """
+ if self.p1.x < self.p2.x:
+ return S.Infinity
+ elif self.p1.x == self.p2.x:
+ return S.Zero
+ else:
+ return S.NegativeInfinity
+
+ @property
+ def ydirection(self):
+ """The y direction of the ray.
+
+ Positive infinity if the ray points in the positive y direction,
+ negative infinity if the ray points in the negative y direction,
+ or 0 if the ray is horizontal.
+
+ See Also
+ ========
+
+ xdirection
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Ray3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(-1, -1, -1), Point3D(-1, 0, 0)
+ >>> r1, r2 = Ray3D(p1, p2), Ray3D(p1, p3)
+ >>> r1.ydirection
+ -oo
+ >>> r2.ydirection
+ 0
+
+ """
+ if self.p1.y < self.p2.y:
+ return S.Infinity
+ elif self.p1.y == self.p2.y:
+ return S.Zero
+ else:
+ return S.NegativeInfinity
+
+ @property
+ def zdirection(self):
+ """The z direction of the ray.
+
+ Positive infinity if the ray points in the positive z direction,
+ negative infinity if the ray points in the negative z direction,
+ or 0 if the ray is horizontal.
+
+ See Also
+ ========
+
+ xdirection
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Ray3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(-1, -1, -1), Point3D(-1, 0, 0)
+ >>> r1, r2 = Ray3D(p1, p2), Ray3D(p1, p3)
+ >>> r1.ydirection
+ -oo
+ >>> r2.ydirection
+ 0
+ >>> r2.zdirection
+ 0
+
+ """
+ if self.p1.z < self.p2.z:
+ return S.Infinity
+ elif self.p1.z == self.p2.z:
+ return S.Zero
+ else:
+ return S.NegativeInfinity
+
+
+class Segment3D(LinearEntity3D, Segment):
+ """A line segment in a 3D space.
+
+ Parameters
+ ==========
+
+ p1 : Point3D
+ p2 : Point3D
+
+ Attributes
+ ==========
+
+ length : number or SymPy expression
+ midpoint : Point3D
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point3D, Line3D
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Segment3D
+ >>> Segment3D((1, 0, 0), (1, 1, 1)) # tuples are interpreted as pts
+ Segment3D(Point3D(1, 0, 0), Point3D(1, 1, 1))
+ >>> s = Segment3D(Point3D(4, 3, 9), Point3D(1, 1, 7)); s
+ Segment3D(Point3D(4, 3, 9), Point3D(1, 1, 7))
+ >>> s.points
+ (Point3D(4, 3, 9), Point3D(1, 1, 7))
+ >>> s.length
+ sqrt(17)
+ >>> s.midpoint
+ Point3D(5/2, 2, 8)
+
+ """
+ def __new__(cls, p1, p2, **kwargs):
+ p1 = Point(p1, dim=3)
+ p2 = Point(p2, dim=3)
+
+ if p1 == p2:
+ return p1
+
+ return LinearEntity3D.__new__(cls, p1, p2, **kwargs)
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/plane.py b/janus/lib/python3.10/site-packages/sympy/geometry/plane.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe00ade7511f3f0b158b0d759cb3323232bcf478
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/geometry/plane.py
@@ -0,0 +1,885 @@
+"""Geometrical Planes.
+
+Contains
+========
+Plane
+
+"""
+
+from sympy.core import Dummy, Rational, S, Symbol
+from sympy.core.symbol import _symbol
+from sympy.functions.elementary.trigonometric import cos, sin, acos, asin, sqrt
+from .entity import GeometryEntity
+from .line import (Line, Ray, Segment, Line3D, LinearEntity, LinearEntity3D,
+ Ray3D, Segment3D)
+from .point import Point, Point3D
+from sympy.matrices import Matrix
+from sympy.polys.polytools import cancel
+from sympy.solvers import solve, linsolve
+from sympy.utilities.iterables import uniq, is_sequence
+from sympy.utilities.misc import filldedent, func_name, Undecidable
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+import random
+
+
+x, y, z, t = [Dummy('plane_dummy') for i in range(4)]
+
+
+class Plane(GeometryEntity):
+ """
+ A plane is a flat, two-dimensional surface. A plane is the two-dimensional
+ analogue of a point (zero-dimensions), a line (one-dimension) and a solid
+ (three-dimensions). A plane can generally be constructed by two types of
+ inputs. They are:
+ - three non-collinear points
+ - a point and the plane's normal vector
+
+ Attributes
+ ==========
+
+ p1
+ normal_vector
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> Plane(Point3D(1, 1, 1), Point3D(2, 3, 4), Point3D(2, 2, 2))
+ Plane(Point3D(1, 1, 1), (-1, 2, -1))
+ >>> Plane((1, 1, 1), (2, 3, 4), (2, 2, 2))
+ Plane(Point3D(1, 1, 1), (-1, 2, -1))
+ >>> Plane(Point3D(1, 1, 1), normal_vector=(1,4,7))
+ Plane(Point3D(1, 1, 1), (1, 4, 7))
+
+ """
+ def __new__(cls, p1, a=None, b=None, **kwargs):
+ p1 = Point3D(p1, dim=3)
+ if a and b:
+ p2 = Point(a, dim=3)
+ p3 = Point(b, dim=3)
+ if Point3D.are_collinear(p1, p2, p3):
+ raise ValueError('Enter three non-collinear points')
+ a = p1.direction_ratio(p2)
+ b = p1.direction_ratio(p3)
+ normal_vector = tuple(Matrix(a).cross(Matrix(b)))
+ else:
+ a = kwargs.pop('normal_vector', a)
+ evaluate = kwargs.get('evaluate', True)
+ if is_sequence(a) and len(a) == 3:
+ normal_vector = Point3D(a).args if evaluate else a
+ else:
+ raise ValueError(filldedent('''
+ Either provide 3 3D points or a point with a
+ normal vector expressed as a sequence of length 3'''))
+ if all(coord.is_zero for coord in normal_vector):
+ raise ValueError('Normal vector cannot be zero vector')
+ return GeometryEntity.__new__(cls, p1, normal_vector, **kwargs)
+
+ def __contains__(self, o):
+ k = self.equation(x, y, z)
+ if isinstance(o, (LinearEntity, LinearEntity3D)):
+ d = Point3D(o.arbitrary_point(t))
+ e = k.subs([(x, d.x), (y, d.y), (z, d.z)])
+ return e.equals(0)
+ try:
+ o = Point(o, dim=3, strict=True)
+ d = k.xreplace(dict(zip((x, y, z), o.args)))
+ return d.equals(0)
+ except TypeError:
+ return False
+
+ def _eval_evalf(self, prec=15, **options):
+ pt, tup = self.args
+ dps = prec_to_dps(prec)
+ pt = pt.evalf(n=dps, **options)
+ tup = tuple([i.evalf(n=dps, **options) for i in tup])
+ return self.func(pt, normal_vector=tup, evaluate=False)
+
+ def angle_between(self, o):
+ """Angle between the plane and other geometric entity.
+
+ Parameters
+ ==========
+
+ LinearEntity3D, Plane.
+
+ Returns
+ =======
+
+ angle : angle in radians
+
+ Notes
+ =====
+
+ This method accepts only 3D entities as it's parameter, but if you want
+ to calculate the angle between a 2D entity and a plane you should
+ first convert to a 3D entity by projecting onto a desired plane and
+ then proceed to calculate the angle.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D, Plane
+ >>> a = Plane(Point3D(1, 2, 2), normal_vector=(1, 2, 3))
+ >>> b = Line3D(Point3D(1, 3, 4), Point3D(2, 2, 2))
+ >>> a.angle_between(b)
+ -asin(sqrt(21)/6)
+
+ """
+ if isinstance(o, LinearEntity3D):
+ a = Matrix(self.normal_vector)
+ b = Matrix(o.direction_ratio)
+ c = a.dot(b)
+ d = sqrt(sum(i**2 for i in self.normal_vector))
+ e = sqrt(sum(i**2 for i in o.direction_ratio))
+ return asin(c/(d*e))
+ if isinstance(o, Plane):
+ a = Matrix(self.normal_vector)
+ b = Matrix(o.normal_vector)
+ c = a.dot(b)
+ d = sqrt(sum(i**2 for i in self.normal_vector))
+ e = sqrt(sum(i**2 for i in o.normal_vector))
+ return acos(c/(d*e))
+
+
+ def arbitrary_point(self, u=None, v=None):
+ """ Returns an arbitrary point on the Plane. If given two
+ parameters, the point ranges over the entire plane. If given 1
+ or no parameters, returns a point with one parameter which,
+ when varying from 0 to 2*pi, moves the point in a circle of
+ radius 1 about p1 of the Plane.
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Ray
+ >>> from sympy.abc import u, v, t, r
+ >>> p = Plane((1, 1, 1), normal_vector=(1, 0, 0))
+ >>> p.arbitrary_point(u, v)
+ Point3D(1, u + 1, v + 1)
+ >>> p.arbitrary_point(t)
+ Point3D(1, cos(t) + 1, sin(t) + 1)
+
+ While arbitrary values of u and v can move the point anywhere in
+ the plane, the single-parameter point can be used to construct a
+ ray whose arbitrary point can be located at angle t and radius
+ r from p.p1:
+
+ >>> Ray(p.p1, _).arbitrary_point(r)
+ Point3D(1, r*cos(t) + 1, r*sin(t) + 1)
+
+ Returns
+ =======
+
+ Point3D
+
+ """
+ circle = v is None
+ if circle:
+ u = _symbol(u or 't', real=True)
+ else:
+ u = _symbol(u or 'u', real=True)
+ v = _symbol(v or 'v', real=True)
+ x, y, z = self.normal_vector
+ a, b, c = self.p1.args
+ # x1, y1, z1 is a nonzero vector parallel to the plane
+ if x.is_zero and y.is_zero:
+ x1, y1, z1 = S.One, S.Zero, S.Zero
+ else:
+ x1, y1, z1 = -y, x, S.Zero
+ # x2, y2, z2 is also parallel to the plane, and orthogonal to x1, y1, z1
+ x2, y2, z2 = tuple(Matrix((x, y, z)).cross(Matrix((x1, y1, z1))))
+ if circle:
+ x1, y1, z1 = (w/sqrt(x1**2 + y1**2 + z1**2) for w in (x1, y1, z1))
+ x2, y2, z2 = (w/sqrt(x2**2 + y2**2 + z2**2) for w in (x2, y2, z2))
+ p = Point3D(a + x1*cos(u) + x2*sin(u), \
+ b + y1*cos(u) + y2*sin(u), \
+ c + z1*cos(u) + z2*sin(u))
+ else:
+ p = Point3D(a + x1*u + x2*v, b + y1*u + y2*v, c + z1*u + z2*v)
+ return p
+
+
+ @staticmethod
+ def are_concurrent(*planes):
+ """Is a sequence of Planes concurrent?
+
+ Two or more Planes are concurrent if their intersections
+ are a common line.
+
+ Parameters
+ ==========
+
+ planes: list
+
+ Returns
+ =======
+
+ Boolean
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> a = Plane(Point3D(5, 0, 0), normal_vector=(1, -1, 1))
+ >>> b = Plane(Point3D(0, -2, 0), normal_vector=(3, 1, 1))
+ >>> c = Plane(Point3D(0, -1, 0), normal_vector=(5, -1, 9))
+ >>> Plane.are_concurrent(a, b)
+ True
+ >>> Plane.are_concurrent(a, b, c)
+ False
+
+ """
+ planes = list(uniq(planes))
+ for i in planes:
+ if not isinstance(i, Plane):
+ raise ValueError('All objects should be Planes but got %s' % i.func)
+ if len(planes) < 2:
+ return False
+ planes = list(planes)
+ first = planes.pop(0)
+ sol = first.intersection(planes[0])
+ if sol == []:
+ return False
+ else:
+ line = sol[0]
+ for i in planes[1:]:
+ l = first.intersection(i)
+ if not l or l[0] not in line:
+ return False
+ return True
+
+
+ def distance(self, o):
+ """Distance between the plane and another geometric entity.
+
+ Parameters
+ ==========
+
+ Point3D, LinearEntity3D, Plane.
+
+ Returns
+ =======
+
+ distance
+
+ Notes
+ =====
+
+ This method accepts only 3D entities as it's parameter, but if you want
+ to calculate the distance between a 2D entity and a plane you should
+ first convert to a 3D entity by projecting onto a desired plane and
+ then proceed to calculate the distance.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D, Plane
+ >>> a = Plane(Point3D(1, 1, 1), normal_vector=(1, 1, 1))
+ >>> b = Point3D(1, 2, 3)
+ >>> a.distance(b)
+ sqrt(3)
+ >>> c = Line3D(Point3D(2, 3, 1), Point3D(1, 2, 2))
+ >>> a.distance(c)
+ 0
+
+ """
+ if self.intersection(o) != []:
+ return S.Zero
+
+ if isinstance(o, (Segment3D, Ray3D)):
+ a, b = o.p1, o.p2
+ pi, = self.intersection(Line3D(a, b))
+ if pi in o:
+ return self.distance(pi)
+ elif a in Segment3D(pi, b):
+ return self.distance(a)
+ else:
+ assert isinstance(o, Segment3D) is True
+ return self.distance(b)
+
+ # following code handles `Point3D`, `LinearEntity3D`, `Plane`
+ a = o if isinstance(o, Point3D) else o.p1
+ n = Point3D(self.normal_vector).unit
+ d = (a - self.p1).dot(n)
+ return abs(d)
+
+
+ def equals(self, o):
+ """
+ Returns True if self and o are the same mathematical entities.
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> a = Plane(Point3D(1, 2, 3), normal_vector=(1, 1, 1))
+ >>> b = Plane(Point3D(1, 2, 3), normal_vector=(2, 2, 2))
+ >>> c = Plane(Point3D(1, 2, 3), normal_vector=(-1, 4, 6))
+ >>> a.equals(a)
+ True
+ >>> a.equals(b)
+ True
+ >>> a.equals(c)
+ False
+ """
+ if isinstance(o, Plane):
+ a = self.equation()
+ b = o.equation()
+ return cancel(a/b).is_constant()
+ else:
+ return False
+
+
+ def equation(self, x=None, y=None, z=None):
+ """The equation of the Plane.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Plane
+ >>> a = Plane(Point3D(1, 1, 2), Point3D(2, 4, 7), Point3D(3, 5, 1))
+ >>> a.equation()
+ -23*x + 11*y - 2*z + 16
+ >>> a = Plane(Point3D(1, 4, 2), normal_vector=(6, 6, 6))
+ >>> a.equation()
+ 6*x + 6*y + 6*z - 42
+
+ """
+ x, y, z = [i if i else Symbol(j, real=True) for i, j in zip((x, y, z), 'xyz')]
+ a = Point3D(x, y, z)
+ b = self.p1.direction_ratio(a)
+ c = self.normal_vector
+ return (sum(i*j for i, j in zip(b, c)))
+
+
+ def intersection(self, o):
+ """ The intersection with other geometrical entity.
+
+ Parameters
+ ==========
+
+ Point, Point3D, LinearEntity, LinearEntity3D, Plane
+
+ Returns
+ =======
+
+ List
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D, Plane
+ >>> a = Plane(Point3D(1, 2, 3), normal_vector=(1, 1, 1))
+ >>> b = Point3D(1, 2, 3)
+ >>> a.intersection(b)
+ [Point3D(1, 2, 3)]
+ >>> c = Line3D(Point3D(1, 4, 7), Point3D(2, 2, 2))
+ >>> a.intersection(c)
+ [Point3D(2, 2, 2)]
+ >>> d = Plane(Point3D(6, 0, 0), normal_vector=(2, -5, 3))
+ >>> e = Plane(Point3D(2, 0, 0), normal_vector=(3, 4, -3))
+ >>> d.intersection(e)
+ [Line3D(Point3D(78/23, -24/23, 0), Point3D(147/23, 321/23, 23))]
+
+ """
+ if not isinstance(o, GeometryEntity):
+ o = Point(o, dim=3)
+ if isinstance(o, Point):
+ if o in self:
+ return [o]
+ else:
+ return []
+ if isinstance(o, (LinearEntity, LinearEntity3D)):
+ # recast to 3D
+ p1, p2 = o.p1, o.p2
+ if isinstance(o, Segment):
+ o = Segment3D(p1, p2)
+ elif isinstance(o, Ray):
+ o = Ray3D(p1, p2)
+ elif isinstance(o, Line):
+ o = Line3D(p1, p2)
+ else:
+ raise ValueError('unhandled linear entity: %s' % o.func)
+ if o in self:
+ return [o]
+ else:
+ a = Point3D(o.arbitrary_point(t))
+ p1, n = self.p1, Point3D(self.normal_vector)
+
+ # TODO: Replace solve with solveset, when this line is tested
+ c = solve((a - p1).dot(n), t)
+ if not c:
+ return []
+ else:
+ c = [i for i in c if i.is_real is not False]
+ if len(c) > 1:
+ c = [i for i in c if i.is_real]
+ if len(c) != 1:
+ raise Undecidable("not sure which point is real")
+ p = a.subs(t, c[0])
+ if p not in o:
+ return [] # e.g. a segment might not intersect a plane
+ return [p]
+ if isinstance(o, Plane):
+ if self.equals(o):
+ return [self]
+ if self.is_parallel(o):
+ return []
+ else:
+ x, y, z = map(Dummy, 'xyz')
+ a, b = Matrix([self.normal_vector]), Matrix([o.normal_vector])
+ c = list(a.cross(b))
+ d = self.equation(x, y, z)
+ e = o.equation(x, y, z)
+ result = list(linsolve([d, e], x, y, z))[0]
+ for i in (x, y, z): result = result.subs(i, 0)
+ return [Line3D(Point3D(result), direction_ratio=c)]
+
+
+ def is_coplanar(self, o):
+ """ Returns True if `o` is coplanar with self, else False.
+
+ Examples
+ ========
+
+ >>> from sympy import Plane
+ >>> o = (0, 0, 0)
+ >>> p = Plane(o, (1, 1, 1))
+ >>> p2 = Plane(o, (2, 2, 2))
+ >>> p == p2
+ False
+ >>> p.is_coplanar(p2)
+ True
+ """
+ if isinstance(o, Plane):
+ return not cancel(self.equation(x, y, z)/o.equation(x, y, z)).has(x, y, z)
+ if isinstance(o, Point3D):
+ return o in self
+ elif isinstance(o, LinearEntity3D):
+ return all(i in self for i in self)
+ elif isinstance(o, GeometryEntity): # XXX should only be handling 2D objects now
+ return all(i == 0 for i in self.normal_vector[:2])
+
+
+ def is_parallel(self, l):
+ """Is the given geometric entity parallel to the plane?
+
+ Parameters
+ ==========
+
+ LinearEntity3D or Plane
+
+ Returns
+ =======
+
+ Boolean
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> a = Plane(Point3D(1,4,6), normal_vector=(2, 4, 6))
+ >>> b = Plane(Point3D(3,1,3), normal_vector=(4, 8, 12))
+ >>> a.is_parallel(b)
+ True
+
+ """
+ if isinstance(l, LinearEntity3D):
+ a = l.direction_ratio
+ b = self.normal_vector
+ c = sum(i*j for i, j in zip(a, b))
+ if c == 0:
+ return True
+ else:
+ return False
+ elif isinstance(l, Plane):
+ a = Matrix(l.normal_vector)
+ b = Matrix(self.normal_vector)
+ if a.cross(b).is_zero_matrix:
+ return True
+ else:
+ return False
+
+
+ def is_perpendicular(self, l):
+ """Is the given geometric entity perpendicualar to the given plane?
+
+ Parameters
+ ==========
+
+ LinearEntity3D or Plane
+
+ Returns
+ =======
+
+ Boolean
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> a = Plane(Point3D(1,4,6), normal_vector=(2, 4, 6))
+ >>> b = Plane(Point3D(2, 2, 2), normal_vector=(-1, 2, -1))
+ >>> a.is_perpendicular(b)
+ True
+
+ """
+ if isinstance(l, LinearEntity3D):
+ a = Matrix(l.direction_ratio)
+ b = Matrix(self.normal_vector)
+ if a.cross(b).is_zero_matrix:
+ return True
+ else:
+ return False
+ elif isinstance(l, Plane):
+ a = Matrix(l.normal_vector)
+ b = Matrix(self.normal_vector)
+ if a.dot(b) == 0:
+ return True
+ else:
+ return False
+ else:
+ return False
+
+ @property
+ def normal_vector(self):
+ """Normal vector of the given plane.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Plane
+ >>> a = Plane(Point3D(1, 1, 1), Point3D(2, 3, 4), Point3D(2, 2, 2))
+ >>> a.normal_vector
+ (-1, 2, -1)
+ >>> a = Plane(Point3D(1, 1, 1), normal_vector=(1, 4, 7))
+ >>> a.normal_vector
+ (1, 4, 7)
+
+ """
+ return self.args[1]
+
+ @property
+ def p1(self):
+ """The only defining point of the plane. Others can be obtained from the
+ arbitrary_point method.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point3D
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Plane
+ >>> a = Plane(Point3D(1, 1, 1), Point3D(2, 3, 4), Point3D(2, 2, 2))
+ >>> a.p1
+ Point3D(1, 1, 1)
+
+ """
+ return self.args[0]
+
+ def parallel_plane(self, pt):
+ """
+ Plane parallel to the given plane and passing through the point pt.
+
+ Parameters
+ ==========
+
+ pt: Point3D
+
+ Returns
+ =======
+
+ Plane
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> a = Plane(Point3D(1, 4, 6), normal_vector=(2, 4, 6))
+ >>> a.parallel_plane(Point3D(2, 3, 5))
+ Plane(Point3D(2, 3, 5), (2, 4, 6))
+
+ """
+ a = self.normal_vector
+ return Plane(pt, normal_vector=a)
+
+ def perpendicular_line(self, pt):
+ """A line perpendicular to the given plane.
+
+ Parameters
+ ==========
+
+ pt: Point3D
+
+ Returns
+ =======
+
+ Line3D
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> a = Plane(Point3D(1,4,6), normal_vector=(2, 4, 6))
+ >>> a.perpendicular_line(Point3D(9, 8, 7))
+ Line3D(Point3D(9, 8, 7), Point3D(11, 12, 13))
+
+ """
+ a = self.normal_vector
+ return Line3D(pt, direction_ratio=a)
+
+ def perpendicular_plane(self, *pts):
+ """
+ Return a perpendicular passing through the given points. If the
+ direction ratio between the points is the same as the Plane's normal
+ vector then, to select from the infinite number of possible planes,
+ a third point will be chosen on the z-axis (or the y-axis
+ if the normal vector is already parallel to the z-axis). If less than
+ two points are given they will be supplied as follows: if no point is
+ given then pt1 will be self.p1; if a second point is not given it will
+ be a point through pt1 on a line parallel to the z-axis (if the normal
+ is not already the z-axis, otherwise on the line parallel to the
+ y-axis).
+
+ Parameters
+ ==========
+
+ pts: 0, 1 or 2 Point3D
+
+ Returns
+ =======
+
+ Plane
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> a, b = Point3D(0, 0, 0), Point3D(0, 1, 0)
+ >>> Z = (0, 0, 1)
+ >>> p = Plane(a, normal_vector=Z)
+ >>> p.perpendicular_plane(a, b)
+ Plane(Point3D(0, 0, 0), (1, 0, 0))
+ """
+ if len(pts) > 2:
+ raise ValueError('No more than 2 pts should be provided.')
+
+ pts = list(pts)
+ if len(pts) == 0:
+ pts.append(self.p1)
+ if len(pts) == 1:
+ x, y, z = self.normal_vector
+ if x == y == 0:
+ dir = (0, 1, 0)
+ else:
+ dir = (0, 0, 1)
+ pts.append(pts[0] + Point3D(*dir))
+
+ p1, p2 = [Point(i, dim=3) for i in pts]
+ l = Line3D(p1, p2)
+ n = Line3D(p1, direction_ratio=self.normal_vector)
+ if l in n: # XXX should an error be raised instead?
+ # there are infinitely many perpendicular planes;
+ x, y, z = self.normal_vector
+ if x == y == 0:
+ # the z axis is the normal so pick a pt on the y-axis
+ p3 = Point3D(0, 1, 0) # case 1
+ else:
+ # else pick a pt on the z axis
+ p3 = Point3D(0, 0, 1) # case 2
+ # in case that point is already given, move it a bit
+ if p3 in l:
+ p3 *= 2 # case 3
+ else:
+ p3 = p1 + Point3D(*self.normal_vector) # case 4
+ return Plane(p1, p2, p3)
+
+ def projection_line(self, line):
+ """Project the given line onto the plane through the normal plane
+ containing the line.
+
+ Parameters
+ ==========
+
+ LinearEntity or LinearEntity3D
+
+ Returns
+ =======
+
+ Point3D, Line3D, Ray3D or Segment3D
+
+ Notes
+ =====
+
+ For the interaction between 2D and 3D lines(segments, rays), you should
+ convert the line to 3D by using this method. For example for finding the
+ intersection between a 2D and a 3D line, convert the 2D line to a 3D line
+ by projecting it on a required plane and then proceed to find the
+ intersection between those lines.
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Line, Line3D, Point3D
+ >>> a = Plane(Point3D(1, 1, 1), normal_vector=(1, 1, 1))
+ >>> b = Line(Point3D(1, 1), Point3D(2, 2))
+ >>> a.projection_line(b)
+ Line3D(Point3D(4/3, 4/3, 1/3), Point3D(5/3, 5/3, -1/3))
+ >>> c = Line3D(Point3D(1, 1, 1), Point3D(2, 2, 2))
+ >>> a.projection_line(c)
+ Point3D(1, 1, 1)
+
+ """
+ if not isinstance(line, (LinearEntity, LinearEntity3D)):
+ raise NotImplementedError('Enter a linear entity only')
+ a, b = self.projection(line.p1), self.projection(line.p2)
+ if a == b:
+ # projection does not imply intersection so for
+ # this case (line parallel to plane's normal) we
+ # return the projection point
+ return a
+ if isinstance(line, (Line, Line3D)):
+ return Line3D(a, b)
+ if isinstance(line, (Ray, Ray3D)):
+ return Ray3D(a, b)
+ if isinstance(line, (Segment, Segment3D)):
+ return Segment3D(a, b)
+
+ def projection(self, pt):
+ """Project the given point onto the plane along the plane normal.
+
+ Parameters
+ ==========
+
+ Point or Point3D
+
+ Returns
+ =======
+
+ Point3D
+
+ Examples
+ ========
+
+ >>> from sympy import Plane, Point3D
+ >>> A = Plane(Point3D(1, 1, 2), normal_vector=(1, 1, 1))
+
+ The projection is along the normal vector direction, not the z
+ axis, so (1, 1) does not project to (1, 1, 2) on the plane A:
+
+ >>> b = Point3D(1, 1)
+ >>> A.projection(b)
+ Point3D(5/3, 5/3, 2/3)
+ >>> _ in A
+ True
+
+ But the point (1, 1, 2) projects to (1, 1) on the XY-plane:
+
+ >>> XY = Plane((0, 0, 0), (0, 0, 1))
+ >>> XY.projection((1, 1, 2))
+ Point3D(1, 1, 0)
+ """
+ rv = Point(pt, dim=3)
+ if rv in self:
+ return rv
+ return self.intersection(Line3D(rv, rv + Point3D(self.normal_vector)))[0]
+
+ def random_point(self, seed=None):
+ """ Returns a random point on the Plane.
+
+ Returns
+ =======
+
+ Point3D
+
+ Examples
+ ========
+
+ >>> from sympy import Plane
+ >>> p = Plane((1, 0, 0), normal_vector=(0, 1, 0))
+ >>> r = p.random_point(seed=42) # seed value is optional
+ >>> r.n(3)
+ Point3D(2.29, 0, -1.35)
+
+ The random point can be moved to lie on the circle of radius
+ 1 centered on p1:
+
+ >>> c = p.p1 + (r - p.p1).unit
+ >>> c.distance(p.p1).equals(1)
+ True
+ """
+ if seed is not None:
+ rng = random.Random(seed)
+ else:
+ rng = random
+ params = {
+ x: 2*Rational(rng.gauss(0, 1)) - 1,
+ y: 2*Rational(rng.gauss(0, 1)) - 1}
+ return self.arbitrary_point(x, y).subs(params)
+
+ def parameter_value(self, other, u, v=None):
+ """Return the parameter(s) corresponding to the given point.
+
+ Examples
+ ========
+
+ >>> from sympy import pi, Plane
+ >>> from sympy.abc import t, u, v
+ >>> p = Plane((2, 0, 0), (0, 0, 1), (0, 1, 0))
+
+ By default, the parameter value returned defines a point
+ that is a distance of 1 from the Plane's p1 value and
+ in line with the given point:
+
+ >>> on_circle = p.arbitrary_point(t).subs(t, pi/4)
+ >>> on_circle.distance(p.p1)
+ 1
+ >>> p.parameter_value(on_circle, t)
+ {t: pi/4}
+
+ Moving the point twice as far from p1 does not change
+ the parameter value:
+
+ >>> off_circle = p.p1 + (on_circle - p.p1)*2
+ >>> off_circle.distance(p.p1)
+ 2
+ >>> p.parameter_value(off_circle, t)
+ {t: pi/4}
+
+ If the 2-value parameter is desired, supply the two
+ parameter symbols and a replacement dictionary will
+ be returned:
+
+ >>> p.parameter_value(on_circle, u, v)
+ {u: sqrt(10)/10, v: sqrt(10)/30}
+ >>> p.parameter_value(off_circle, u, v)
+ {u: sqrt(10)/5, v: sqrt(10)/15}
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if not isinstance(other, Point):
+ raise ValueError("other must be a point")
+ if other == self.p1:
+ return other
+ if isinstance(u, Symbol) and v is None:
+ delta = self.arbitrary_point(u) - self.p1
+ eq = delta - (other - self.p1).unit
+ sol = solve(eq, u, dict=True)
+ elif isinstance(u, Symbol) and isinstance(v, Symbol):
+ pt = self.arbitrary_point(u, v)
+ sol = solve(pt - other, (u, v), dict=True)
+ else:
+ raise ValueError('expecting 1 or 2 symbols')
+ if not sol:
+ raise ValueError("Given point is not on %s" % func_name(self))
+ return sol[0] # {t: tval} or {u: uval, v: vval}
+
+ @property
+ def ambient_dimension(self):
+ return self.p1.ambient_dimension
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/point.py b/janus/lib/python3.10/site-packages/sympy/geometry/point.py
new file mode 100644
index 0000000000000000000000000000000000000000..81ca7ce61a08d139d2a0d13e545ce008ba9c4298
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/geometry/point.py
@@ -0,0 +1,1378 @@
+"""Geometrical Points.
+
+Contains
+========
+Point
+Point2D
+Point3D
+
+When methods of Point require 1 or more points as arguments, they
+can be passed as a sequence of coordinates or Points:
+
+>>> from sympy import Point
+>>> Point(1, 1).is_collinear((2, 2), (3, 4))
+False
+>>> Point(1, 1).is_collinear(Point(2, 2), Point(3, 4))
+False
+
+"""
+
+import warnings
+
+from sympy.core import S, sympify, Expr
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.numbers import Float
+from sympy.core.parameters import global_parameters
+from sympy.simplify import nsimplify, simplify
+from sympy.geometry.exceptions import GeometryError
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.complexes import im
+from sympy.functions.elementary.trigonometric import cos, sin
+from sympy.matrices import Matrix
+from sympy.matrices.expressions import Transpose
+from sympy.utilities.iterables import uniq, is_sequence
+from sympy.utilities.misc import filldedent, func_name, Undecidable
+
+from .entity import GeometryEntity
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+class Point(GeometryEntity):
+ """A point in a n-dimensional Euclidean space.
+
+ Parameters
+ ==========
+
+ coords : sequence of n-coordinate values. In the special
+ case where n=2 or 3, a Point2D or Point3D will be created
+ as appropriate.
+ evaluate : if `True` (default), all floats are turn into
+ exact types.
+ dim : number of coordinates the point should have. If coordinates
+ are unspecified, they are padded with zeros.
+ on_morph : indicates what should happen when the number of
+ coordinates of a point need to be changed by adding or
+ removing zeros. Possible values are `'warn'`, `'error'`, or
+ `ignore` (default). No warning or error is given when `*args`
+ is empty and `dim` is given. An error is always raised when
+ trying to remove nonzero coordinates.
+
+
+ Attributes
+ ==========
+
+ length
+ origin: A `Point` representing the origin of the
+ appropriately-dimensioned space.
+
+ Raises
+ ======
+
+ TypeError : When instantiating with anything but a Point or sequence
+ ValueError : when instantiating with a sequence with length < 2 or
+ when trying to reduce dimensions if keyword `on_morph='error'` is
+ set.
+
+ See Also
+ ========
+
+ sympy.geometry.line.Segment : Connects two Points
+
+ Examples
+ ========
+
+ >>> from sympy import Point
+ >>> from sympy.abc import x
+ >>> Point(1, 2, 3)
+ Point3D(1, 2, 3)
+ >>> Point([1, 2])
+ Point2D(1, 2)
+ >>> Point(0, x)
+ Point2D(0, x)
+ >>> Point(dim=4)
+ Point(0, 0, 0, 0)
+
+ Floats are automatically converted to Rational unless the
+ evaluate flag is False:
+
+ >>> Point(0.5, 0.25)
+ Point2D(1/2, 1/4)
+ >>> Point(0.5, 0.25, evaluate=False)
+ Point2D(0.5, 0.25)
+
+ """
+
+ is_Point = True
+
+ def __new__(cls, *args, **kwargs):
+ evaluate = kwargs.get('evaluate', global_parameters.evaluate)
+ on_morph = kwargs.get('on_morph', 'ignore')
+
+ # unpack into coords
+ coords = args[0] if len(args) == 1 else args
+
+ # check args and handle quickly handle Point instances
+ if isinstance(coords, Point):
+ # even if we're mutating the dimension of a point, we
+ # don't reevaluate its coordinates
+ evaluate = False
+ if len(coords) == kwargs.get('dim', len(coords)):
+ return coords
+
+ if not is_sequence(coords):
+ raise TypeError(filldedent('''
+ Expecting sequence of coordinates, not `{}`'''
+ .format(func_name(coords))))
+ # A point where only `dim` is specified is initialized
+ # to zeros.
+ if len(coords) == 0 and kwargs.get('dim', None):
+ coords = (S.Zero,)*kwargs.get('dim')
+
+ coords = Tuple(*coords)
+ dim = kwargs.get('dim', len(coords))
+
+ if len(coords) < 2:
+ raise ValueError(filldedent('''
+ Point requires 2 or more coordinates or
+ keyword `dim` > 1.'''))
+ if len(coords) != dim:
+ message = ("Dimension of {} needs to be changed "
+ "from {} to {}.").format(coords, len(coords), dim)
+ if on_morph == 'ignore':
+ pass
+ elif on_morph == "error":
+ raise ValueError(message)
+ elif on_morph == 'warn':
+ warnings.warn(message, stacklevel=2)
+ else:
+ raise ValueError(filldedent('''
+ on_morph value should be 'error',
+ 'warn' or 'ignore'.'''))
+ if any(coords[dim:]):
+ raise ValueError('Nonzero coordinates cannot be removed.')
+ if any(a.is_number and im(a).is_zero is False for a in coords):
+ raise ValueError('Imaginary coordinates are not permitted.')
+ if not all(isinstance(a, Expr) for a in coords):
+ raise TypeError('Coordinates must be valid SymPy expressions.')
+
+ # pad with zeros appropriately
+ coords = coords[:dim] + (S.Zero,)*(dim - len(coords))
+
+ # Turn any Floats into rationals and simplify
+ # any expressions before we instantiate
+ if evaluate:
+ coords = coords.xreplace({
+ f: simplify(nsimplify(f, rational=True))
+ for f in coords.atoms(Float)})
+
+ # return 2D or 3D instances
+ if len(coords) == 2:
+ kwargs['_nocheck'] = True
+ return Point2D(*coords, **kwargs)
+ elif len(coords) == 3:
+ kwargs['_nocheck'] = True
+ return Point3D(*coords, **kwargs)
+
+ # the general Point
+ return GeometryEntity.__new__(cls, *coords)
+
+ def __abs__(self):
+ """Returns the distance between this point and the origin."""
+ origin = Point([0]*len(self))
+ return Point.distance(origin, self)
+
+ def __add__(self, other):
+ """Add other to self by incrementing self's coordinates by
+ those of other.
+
+ Notes
+ =====
+
+ >>> from sympy import Point
+
+ When sequences of coordinates are passed to Point methods, they
+ are converted to a Point internally. This __add__ method does
+ not do that so if floating point values are used, a floating
+ point result (in terms of SymPy Floats) will be returned.
+
+ >>> Point(1, 2) + (.1, .2)
+ Point2D(1.1, 2.2)
+
+ If this is not desired, the `translate` method can be used or
+ another Point can be added:
+
+ >>> Point(1, 2).translate(.1, .2)
+ Point2D(11/10, 11/5)
+ >>> Point(1, 2) + Point(.1, .2)
+ Point2D(11/10, 11/5)
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point.translate
+
+ """
+ try:
+ s, o = Point._normalize_dimension(self, Point(other, evaluate=False))
+ except TypeError:
+ raise GeometryError("Don't know how to add {} and a Point object".format(other))
+
+ coords = [simplify(a + b) for a, b in zip(s, o)]
+ return Point(coords, evaluate=False)
+
+ def __contains__(self, item):
+ return item in self.args
+
+ def __truediv__(self, divisor):
+ """Divide point's coordinates by a factor."""
+ divisor = sympify(divisor)
+ coords = [simplify(x/divisor) for x in self.args]
+ return Point(coords, evaluate=False)
+
+ def __eq__(self, other):
+ if not isinstance(other, Point) or len(self.args) != len(other.args):
+ return False
+ return self.args == other.args
+
+ def __getitem__(self, key):
+ return self.args[key]
+
+ def __hash__(self):
+ return hash(self.args)
+
+ def __iter__(self):
+ return self.args.__iter__()
+
+ def __len__(self):
+ return len(self.args)
+
+ def __mul__(self, factor):
+ """Multiply point's coordinates by a factor.
+
+ Notes
+ =====
+
+ >>> from sympy import Point
+
+ When multiplying a Point by a floating point number,
+ the coordinates of the Point will be changed to Floats:
+
+ >>> Point(1, 2)*0.1
+ Point2D(0.1, 0.2)
+
+ If this is not desired, the `scale` method can be used or
+ else only multiply or divide by integers:
+
+ >>> Point(1, 2).scale(1.1, 1.1)
+ Point2D(11/10, 11/5)
+ >>> Point(1, 2)*11/10
+ Point2D(11/10, 11/5)
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point.scale
+ """
+ factor = sympify(factor)
+ coords = [simplify(x*factor) for x in self.args]
+ return Point(coords, evaluate=False)
+
+ def __rmul__(self, factor):
+ """Multiply a factor by point's coordinates."""
+ return self.__mul__(factor)
+
+ def __neg__(self):
+ """Negate the point."""
+ coords = [-x for x in self.args]
+ return Point(coords, evaluate=False)
+
+ def __sub__(self, other):
+ """Subtract two points, or subtract a factor from this point's
+ coordinates."""
+ return self + [-x for x in other]
+
+ @classmethod
+ def _normalize_dimension(cls, *points, **kwargs):
+ """Ensure that points have the same dimension.
+ By default `on_morph='warn'` is passed to the
+ `Point` constructor."""
+ # if we have a built-in ambient dimension, use it
+ dim = getattr(cls, '_ambient_dimension', None)
+ # override if we specified it
+ dim = kwargs.get('dim', dim)
+ # if no dim was given, use the highest dimensional point
+ if dim is None:
+ dim = max(i.ambient_dimension for i in points)
+ if all(i.ambient_dimension == dim for i in points):
+ return list(points)
+ kwargs['dim'] = dim
+ kwargs['on_morph'] = kwargs.get('on_morph', 'warn')
+ return [Point(i, **kwargs) for i in points]
+
+ @staticmethod
+ def affine_rank(*args):
+ """The affine rank of a set of points is the dimension
+ of the smallest affine space containing all the points.
+ For example, if the points lie on a line (and are not all
+ the same) their affine rank is 1. If the points lie on a plane
+ but not a line, their affine rank is 2. By convention, the empty
+ set has affine rank -1."""
+
+ if len(args) == 0:
+ return -1
+ # make sure we're genuinely points
+ # and translate every point to the origin
+ points = Point._normalize_dimension(*[Point(i) for i in args])
+ origin = points[0]
+ points = [i - origin for i in points[1:]]
+
+ m = Matrix([i.args for i in points])
+ # XXX fragile -- what is a better way?
+ return m.rank(iszerofunc = lambda x:
+ abs(x.n(2)) < 1e-12 if x.is_number else x.is_zero)
+
+ @property
+ def ambient_dimension(self):
+ """Number of components this point has."""
+ return getattr(self, '_ambient_dimension', len(self))
+
+ @classmethod
+ def are_coplanar(cls, *points):
+ """Return True if there exists a plane in which all the points
+ lie. A trivial True value is returned if `len(points) < 3` or
+ all Points are 2-dimensional.
+
+ Parameters
+ ==========
+
+ A set of points
+
+ Raises
+ ======
+
+ ValueError : if less than 3 unique points are given
+
+ Returns
+ =======
+
+ boolean
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> p1 = Point3D(1, 2, 2)
+ >>> p2 = Point3D(2, 7, 2)
+ >>> p3 = Point3D(0, 0, 2)
+ >>> p4 = Point3D(1, 1, 2)
+ >>> Point3D.are_coplanar(p1, p2, p3, p4)
+ True
+ >>> p5 = Point3D(0, 1, 3)
+ >>> Point3D.are_coplanar(p1, p2, p3, p5)
+ False
+
+ """
+ if len(points) <= 1:
+ return True
+
+ points = cls._normalize_dimension(*[Point(i) for i in points])
+ # quick exit if we are in 2D
+ if points[0].ambient_dimension == 2:
+ return True
+ points = list(uniq(points))
+ return Point.affine_rank(*points) <= 2
+
+ def distance(self, other):
+ """The Euclidean distance between self and another GeometricEntity.
+
+ Returns
+ =======
+
+ distance : number or symbolic expression.
+
+ Raises
+ ======
+
+ TypeError : if other is not recognized as a GeometricEntity or is a
+ GeometricEntity for which distance is not defined.
+
+ See Also
+ ========
+
+ sympy.geometry.line.Segment.length
+ sympy.geometry.point.Point.taxicab_distance
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Line
+ >>> p1, p2 = Point(1, 1), Point(4, 5)
+ >>> l = Line((3, 1), (2, 2))
+ >>> p1.distance(p2)
+ 5
+ >>> p1.distance(l)
+ sqrt(2)
+
+ The computed distance may be symbolic, too:
+
+ >>> from sympy.abc import x, y
+ >>> p3 = Point(x, y)
+ >>> p3.distance((0, 0))
+ sqrt(x**2 + y**2)
+
+ """
+ if not isinstance(other, GeometryEntity):
+ try:
+ other = Point(other, dim=self.ambient_dimension)
+ except TypeError:
+ raise TypeError("not recognized as a GeometricEntity: %s" % type(other))
+ if isinstance(other, Point):
+ s, p = Point._normalize_dimension(self, Point(other))
+ return sqrt(Add(*((a - b)**2 for a, b in zip(s, p))))
+ distance = getattr(other, 'distance', None)
+ if distance is None:
+ raise TypeError("distance between Point and %s is not defined" % type(other))
+ return distance(self)
+
+ def dot(self, p):
+ """Return dot product of self with another Point."""
+ if not is_sequence(p):
+ p = Point(p) # raise the error via Point
+ return Add(*(a*b for a, b in zip(self, p)))
+
+ def equals(self, other):
+ """Returns whether the coordinates of self and other agree."""
+ # a point is equal to another point if all its components are equal
+ if not isinstance(other, Point) or len(self) != len(other):
+ return False
+ return all(a.equals(b) for a, b in zip(self, other))
+
+ def _eval_evalf(self, prec=15, **options):
+ """Evaluate the coordinates of the point.
+
+ This method will, where possible, create and return a new Point
+ where the coordinates are evaluated as floating point numbers to
+ the precision indicated (default=15).
+
+ Parameters
+ ==========
+
+ prec : int
+
+ Returns
+ =======
+
+ point : Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Rational
+ >>> p1 = Point(Rational(1, 2), Rational(3, 2))
+ >>> p1
+ Point2D(1/2, 3/2)
+ >>> p1.evalf()
+ Point2D(0.5, 1.5)
+
+ """
+ dps = prec_to_dps(prec)
+ coords = [x.evalf(n=dps, **options) for x in self.args]
+ return Point(*coords, evaluate=False)
+
+ def intersection(self, other):
+ """The intersection between this point and another GeometryEntity.
+
+ Parameters
+ ==========
+
+ other : GeometryEntity or sequence of coordinates
+
+ Returns
+ =======
+
+ intersection : list of Points
+
+ Notes
+ =====
+
+ The return value will either be an empty list if there is no
+ intersection, otherwise it will contain this point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(0, 0)
+ >>> p1.intersection(p2)
+ []
+ >>> p1.intersection(p3)
+ [Point2D(0, 0)]
+
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other)
+ if isinstance(other, Point):
+ if self == other:
+ return [self]
+ p1, p2 = Point._normalize_dimension(self, other)
+ if p1 == self and p1 == p2:
+ return [self]
+ return []
+ return other.intersection(self)
+
+ def is_collinear(self, *args):
+ """Returns `True` if there exists a line
+ that contains `self` and `points`. Returns `False` otherwise.
+ A trivially True value is returned if no points are given.
+
+ Parameters
+ ==========
+
+ args : sequence of Points
+
+ Returns
+ =======
+
+ is_collinear : boolean
+
+ See Also
+ ========
+
+ sympy.geometry.line.Line
+
+ Examples
+ ========
+
+ >>> from sympy import Point
+ >>> from sympy.abc import x
+ >>> p1, p2 = Point(0, 0), Point(1, 1)
+ >>> p3, p4, p5 = Point(2, 2), Point(x, x), Point(1, 2)
+ >>> Point.is_collinear(p1, p2, p3, p4)
+ True
+ >>> Point.is_collinear(p1, p2, p3, p5)
+ False
+
+ """
+ points = (self,) + args
+ points = Point._normalize_dimension(*[Point(i) for i in points])
+ points = list(uniq(points))
+ return Point.affine_rank(*points) <= 1
+
+ def is_concyclic(self, *args):
+ """Do `self` and the given sequence of points lie in a circle?
+
+ Returns True if the set of points are concyclic and
+ False otherwise. A trivial value of True is returned
+ if there are fewer than 2 other points.
+
+ Parameters
+ ==========
+
+ args : sequence of Points
+
+ Returns
+ =======
+
+ is_concyclic : boolean
+
+
+ Examples
+ ========
+
+ >>> from sympy import Point
+
+ Define 4 points that are on the unit circle:
+
+ >>> p1, p2, p3, p4 = Point(1, 0), (0, 1), (-1, 0), (0, -1)
+
+ >>> p1.is_concyclic() == p1.is_concyclic(p2, p3, p4) == True
+ True
+
+ Define a point not on that circle:
+
+ >>> p = Point(1, 1)
+
+ >>> p.is_concyclic(p1, p2, p3)
+ False
+
+ """
+ points = (self,) + args
+ points = Point._normalize_dimension(*[Point(i) for i in points])
+ points = list(uniq(points))
+ if not Point.affine_rank(*points) <= 2:
+ return False
+ origin = points[0]
+ points = [p - origin for p in points]
+ # points are concyclic if they are coplanar and
+ # there is a point c so that ||p_i-c|| == ||p_j-c|| for all
+ # i and j. Rearranging this equation gives us the following
+ # condition: the matrix `mat` must not a pivot in the last
+ # column.
+ mat = Matrix([list(i) + [i.dot(i)] for i in points])
+ rref, pivots = mat.rref()
+ if len(origin) not in pivots:
+ return True
+ return False
+
+ @property
+ def is_nonzero(self):
+ """True if any coordinate is nonzero, False if every coordinate is zero,
+ and None if it cannot be determined."""
+ is_zero = self.is_zero
+ if is_zero is None:
+ return None
+ return not is_zero
+
+ def is_scalar_multiple(self, p):
+ """Returns whether each coordinate of `self` is a scalar
+ multiple of the corresponding coordinate in point p.
+ """
+ s, o = Point._normalize_dimension(self, Point(p))
+ # 2d points happen a lot, so optimize this function call
+ if s.ambient_dimension == 2:
+ (x1, y1), (x2, y2) = s.args, o.args
+ rv = (x1*y2 - x2*y1).equals(0)
+ if rv is None:
+ raise Undecidable(filldedent(
+ '''Cannot determine if %s is a scalar multiple of
+ %s''' % (s, o)))
+
+ # if the vectors p1 and p2 are linearly dependent, then they must
+ # be scalar multiples of each other
+ m = Matrix([s.args, o.args])
+ return m.rank() < 2
+
+ @property
+ def is_zero(self):
+ """True if every coordinate is zero, False if any coordinate is not zero,
+ and None if it cannot be determined."""
+ nonzero = [x.is_nonzero for x in self.args]
+ if any(nonzero):
+ return False
+ if any(x is None for x in nonzero):
+ return None
+ return True
+
+ @property
+ def length(self):
+ """
+ Treating a Point as a Line, this returns 0 for the length of a Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point
+ >>> p = Point(0, 1)
+ >>> p.length
+ 0
+ """
+ return S.Zero
+
+ def midpoint(self, p):
+ """The midpoint between self and point p.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ midpoint : Point
+
+ See Also
+ ========
+
+ sympy.geometry.line.Segment.midpoint
+
+ Examples
+ ========
+
+ >>> from sympy import Point
+ >>> p1, p2 = Point(1, 1), Point(13, 5)
+ >>> p1.midpoint(p2)
+ Point2D(7, 3)
+
+ """
+ s, p = Point._normalize_dimension(self, Point(p))
+ return Point([simplify((a + b)*S.Half) for a, b in zip(s, p)])
+
+ @property
+ def origin(self):
+ """A point of all zeros of the same ambient dimension
+ as the current point"""
+ return Point([0]*len(self), evaluate=False)
+
+ @property
+ def orthogonal_direction(self):
+ """Returns a non-zero point that is orthogonal to the
+ line containing `self` and the origin.
+
+ Examples
+ ========
+
+ >>> from sympy import Line, Point
+ >>> a = Point(1, 2, 3)
+ >>> a.orthogonal_direction
+ Point3D(-2, 1, 0)
+ >>> b = _
+ >>> Line(b, b.origin).is_perpendicular(Line(a, a.origin))
+ True
+ """
+ dim = self.ambient_dimension
+ # if a coordinate is zero, we can put a 1 there and zeros elsewhere
+ if self[0].is_zero:
+ return Point([1] + (dim - 1)*[0])
+ if self[1].is_zero:
+ return Point([0,1] + (dim - 2)*[0])
+ # if the first two coordinates aren't zero, we can create a non-zero
+ # orthogonal vector by swapping them, negating one, and padding with zeros
+ return Point([-self[1], self[0]] + (dim - 2)*[0])
+
+ @staticmethod
+ def project(a, b):
+ """Project the point `a` onto the line between the origin
+ and point `b` along the normal direction.
+
+ Parameters
+ ==========
+
+ a : Point
+ b : Point
+
+ Returns
+ =======
+
+ p : Point
+
+ See Also
+ ========
+
+ sympy.geometry.line.LinearEntity.projection
+
+ Examples
+ ========
+
+ >>> from sympy import Line, Point
+ >>> a = Point(1, 2)
+ >>> b = Point(2, 5)
+ >>> z = a.origin
+ >>> p = Point.project(a, b)
+ >>> Line(p, a).is_perpendicular(Line(p, b))
+ True
+ >>> Point.is_collinear(z, p, b)
+ True
+ """
+ a, b = Point._normalize_dimension(Point(a), Point(b))
+ if b.is_zero:
+ raise ValueError("Cannot project to the zero vector.")
+ return b*(a.dot(b) / b.dot(b))
+
+ def taxicab_distance(self, p):
+ """The Taxicab Distance from self to point p.
+
+ Returns the sum of the horizontal and vertical distances to point p.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ taxicab_distance : The sum of the horizontal
+ and vertical distances to point p.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point.distance
+
+ Examples
+ ========
+
+ >>> from sympy import Point
+ >>> p1, p2 = Point(1, 1), Point(4, 5)
+ >>> p1.taxicab_distance(p2)
+ 7
+
+ """
+ s, p = Point._normalize_dimension(self, Point(p))
+ return Add(*(abs(a - b) for a, b in zip(s, p)))
+
+ def canberra_distance(self, p):
+ """The Canberra Distance from self to point p.
+
+ Returns the weighted sum of horizontal and vertical distances to
+ point p.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ canberra_distance : The weighted sum of horizontal and vertical
+ distances to point p. The weight used is the sum of absolute values
+ of the coordinates.
+
+ Examples
+ ========
+
+ >>> from sympy import Point
+ >>> p1, p2 = Point(1, 1), Point(3, 3)
+ >>> p1.canberra_distance(p2)
+ 1
+ >>> p1, p2 = Point(0, 0), Point(3, 3)
+ >>> p1.canberra_distance(p2)
+ 2
+
+ Raises
+ ======
+
+ ValueError when both vectors are zero.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point.distance
+
+ """
+
+ s, p = Point._normalize_dimension(self, Point(p))
+ if self.is_zero and p.is_zero:
+ raise ValueError("Cannot project to the zero vector.")
+ return Add(*((abs(a - b)/(abs(a) + abs(b))) for a, b in zip(s, p)))
+
+ @property
+ def unit(self):
+ """Return the Point that is in the same direction as `self`
+ and a distance of 1 from the origin"""
+ return self / abs(self)
+
+
+class Point2D(Point):
+ """A point in a 2-dimensional Euclidean space.
+
+ Parameters
+ ==========
+
+ coords
+ A sequence of 2 coordinate values.
+
+ Attributes
+ ==========
+
+ x
+ y
+ length
+
+ Raises
+ ======
+
+ TypeError
+ When trying to add or subtract points with different dimensions.
+ When trying to create a point with more than two dimensions.
+ When `intersection` is called with object other than a Point.
+
+ See Also
+ ========
+
+ sympy.geometry.line.Segment : Connects two Points
+
+ Examples
+ ========
+
+ >>> from sympy import Point2D
+ >>> from sympy.abc import x
+ >>> Point2D(1, 2)
+ Point2D(1, 2)
+ >>> Point2D([1, 2])
+ Point2D(1, 2)
+ >>> Point2D(0, x)
+ Point2D(0, x)
+
+ Floats are automatically converted to Rational unless the
+ evaluate flag is False:
+
+ >>> Point2D(0.5, 0.25)
+ Point2D(1/2, 1/4)
+ >>> Point2D(0.5, 0.25, evaluate=False)
+ Point2D(0.5, 0.25)
+
+ """
+
+ _ambient_dimension = 2
+
+ def __new__(cls, *args, _nocheck=False, **kwargs):
+ if not _nocheck:
+ kwargs['dim'] = 2
+ args = Point(*args, **kwargs)
+ return GeometryEntity.__new__(cls, *args)
+
+ def __contains__(self, item):
+ return item == self
+
+ @property
+ def bounds(self):
+ """Return a tuple (xmin, ymin, xmax, ymax) representing the bounding
+ rectangle for the geometric figure.
+
+ """
+
+ return (self.x, self.y, self.x, self.y)
+
+ def rotate(self, angle, pt=None):
+ """Rotate ``angle`` radians counterclockwise about Point ``pt``.
+
+ See Also
+ ========
+
+ translate, scale
+
+ Examples
+ ========
+
+ >>> from sympy import Point2D, pi
+ >>> t = Point2D(1, 0)
+ >>> t.rotate(pi/2)
+ Point2D(0, 1)
+ >>> t.rotate(pi/2, (2, 0))
+ Point2D(2, -1)
+
+ """
+ c = cos(angle)
+ s = sin(angle)
+
+ rv = self
+ if pt is not None:
+ pt = Point(pt, dim=2)
+ rv -= pt
+ x, y = rv.args
+ rv = Point(c*x - s*y, s*x + c*y)
+ if pt is not None:
+ rv += pt
+ return rv
+
+ def scale(self, x=1, y=1, pt=None):
+ """Scale the coordinates of the Point by multiplying by
+ ``x`` and ``y`` after subtracting ``pt`` -- default is (0, 0) --
+ and then adding ``pt`` back again (i.e. ``pt`` is the point of
+ reference for the scaling).
+
+ See Also
+ ========
+
+ rotate, translate
+
+ Examples
+ ========
+
+ >>> from sympy import Point2D
+ >>> t = Point2D(1, 1)
+ >>> t.scale(2)
+ Point2D(2, 1)
+ >>> t.scale(2, 2)
+ Point2D(2, 2)
+
+ """
+ if pt:
+ pt = Point(pt, dim=2)
+ return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+ return Point(self.x*x, self.y*y)
+
+ def transform(self, matrix):
+ """Return the point after applying the transformation described
+ by the 3x3 Matrix, ``matrix``.
+
+ See Also
+ ========
+ sympy.geometry.point.Point2D.rotate
+ sympy.geometry.point.Point2D.scale
+ sympy.geometry.point.Point2D.translate
+ """
+ if not (matrix.is_Matrix and matrix.shape == (3, 3)):
+ raise ValueError("matrix must be a 3x3 matrix")
+ x, y = self.args
+ return Point(*(Matrix(1, 3, [x, y, 1])*matrix).tolist()[0][:2])
+
+ def translate(self, x=0, y=0):
+ """Shift the Point by adding x and y to the coordinates of the Point.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point2D.rotate, scale
+
+ Examples
+ ========
+
+ >>> from sympy import Point2D
+ >>> t = Point2D(0, 1)
+ >>> t.translate(2)
+ Point2D(2, 1)
+ >>> t.translate(2, 2)
+ Point2D(2, 3)
+ >>> t + Point2D(2, 2)
+ Point2D(2, 3)
+
+ """
+ return Point(self.x + x, self.y + y)
+
+ @property
+ def coordinates(self):
+ """
+ Returns the two coordinates of the Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point2D
+ >>> p = Point2D(0, 1)
+ >>> p.coordinates
+ (0, 1)
+ """
+ return self.args
+
+ @property
+ def x(self):
+ """
+ Returns the X coordinate of the Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point2D
+ >>> p = Point2D(0, 1)
+ >>> p.x
+ 0
+ """
+ return self.args[0]
+
+ @property
+ def y(self):
+ """
+ Returns the Y coordinate of the Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point2D
+ >>> p = Point2D(0, 1)
+ >>> p.y
+ 1
+ """
+ return self.args[1]
+
+class Point3D(Point):
+ """A point in a 3-dimensional Euclidean space.
+
+ Parameters
+ ==========
+
+ coords
+ A sequence of 3 coordinate values.
+
+ Attributes
+ ==========
+
+ x
+ y
+ z
+ length
+
+ Raises
+ ======
+
+ TypeError
+ When trying to add or subtract points with different dimensions.
+ When `intersection` is called with object other than a Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> from sympy.abc import x
+ >>> Point3D(1, 2, 3)
+ Point3D(1, 2, 3)
+ >>> Point3D([1, 2, 3])
+ Point3D(1, 2, 3)
+ >>> Point3D(0, x, 3)
+ Point3D(0, x, 3)
+
+ Floats are automatically converted to Rational unless the
+ evaluate flag is False:
+
+ >>> Point3D(0.5, 0.25, 2)
+ Point3D(1/2, 1/4, 2)
+ >>> Point3D(0.5, 0.25, 3, evaluate=False)
+ Point3D(0.5, 0.25, 3)
+
+ """
+
+ _ambient_dimension = 3
+
+ def __new__(cls, *args, _nocheck=False, **kwargs):
+ if not _nocheck:
+ kwargs['dim'] = 3
+ args = Point(*args, **kwargs)
+ return GeometryEntity.__new__(cls, *args)
+
+ def __contains__(self, item):
+ return item == self
+
+ @staticmethod
+ def are_collinear(*points):
+ """Is a sequence of points collinear?
+
+ Test whether or not a set of points are collinear. Returns True if
+ the set of points are collinear, or False otherwise.
+
+ Parameters
+ ==========
+
+ points : sequence of Point
+
+ Returns
+ =======
+
+ are_collinear : boolean
+
+ See Also
+ ========
+
+ sympy.geometry.line.Line3D
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> from sympy.abc import x
+ >>> p1, p2 = Point3D(0, 0, 0), Point3D(1, 1, 1)
+ >>> p3, p4, p5 = Point3D(2, 2, 2), Point3D(x, x, x), Point3D(1, 2, 6)
+ >>> Point3D.are_collinear(p1, p2, p3, p4)
+ True
+ >>> Point3D.are_collinear(p1, p2, p3, p5)
+ False
+ """
+ return Point.is_collinear(*points)
+
+ def direction_cosine(self, point):
+ """
+ Gives the direction cosine between 2 points
+
+ Parameters
+ ==========
+
+ p : Point3D
+
+ Returns
+ =======
+
+ list
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> p1 = Point3D(1, 2, 3)
+ >>> p1.direction_cosine(Point3D(2, 3, 5))
+ [sqrt(6)/6, sqrt(6)/6, sqrt(6)/3]
+ """
+ a = self.direction_ratio(point)
+ b = sqrt(Add(*(i**2 for i in a)))
+ return [(point.x - self.x) / b,(point.y - self.y) / b,
+ (point.z - self.z) / b]
+
+ def direction_ratio(self, point):
+ """
+ Gives the direction ratio between 2 points
+
+ Parameters
+ ==========
+
+ p : Point3D
+
+ Returns
+ =======
+
+ list
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> p1 = Point3D(1, 2, 3)
+ >>> p1.direction_ratio(Point3D(2, 3, 5))
+ [1, 1, 2]
+ """
+ return [(point.x - self.x),(point.y - self.y),(point.z - self.z)]
+
+ def intersection(self, other):
+ """The intersection between this point and another GeometryEntity.
+
+ Parameters
+ ==========
+
+ other : GeometryEntity or sequence of coordinates
+
+ Returns
+ =======
+
+ intersection : list of Points
+
+ Notes
+ =====
+
+ The return value will either be an empty list if there is no
+ intersection, otherwise it will contain this point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(0, 0, 0)
+ >>> p1.intersection(p2)
+ []
+ >>> p1.intersection(p3)
+ [Point3D(0, 0, 0)]
+
+ """
+ if not isinstance(other, GeometryEntity):
+ other = Point(other, dim=3)
+ if isinstance(other, Point3D):
+ if self == other:
+ return [self]
+ return []
+ return other.intersection(self)
+
+ def scale(self, x=1, y=1, z=1, pt=None):
+ """Scale the coordinates of the Point by multiplying by
+ ``x`` and ``y`` after subtracting ``pt`` -- default is (0, 0) --
+ and then adding ``pt`` back again (i.e. ``pt`` is the point of
+ reference for the scaling).
+
+ See Also
+ ========
+
+ translate
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> t = Point3D(1, 1, 1)
+ >>> t.scale(2)
+ Point3D(2, 1, 1)
+ >>> t.scale(2, 2)
+ Point3D(2, 2, 1)
+
+ """
+ if pt:
+ pt = Point3D(pt)
+ return self.translate(*(-pt).args).scale(x, y, z).translate(*pt.args)
+ return Point3D(self.x*x, self.y*y, self.z*z)
+
+ def transform(self, matrix):
+ """Return the point after applying the transformation described
+ by the 4x4 Matrix, ``matrix``.
+
+ See Also
+ ========
+ sympy.geometry.point.Point3D.scale
+ sympy.geometry.point.Point3D.translate
+ """
+ if not (matrix.is_Matrix and matrix.shape == (4, 4)):
+ raise ValueError("matrix must be a 4x4 matrix")
+ x, y, z = self.args
+ m = Transpose(matrix)
+ return Point3D(*(Matrix(1, 4, [x, y, z, 1])*m).tolist()[0][:3])
+
+ def translate(self, x=0, y=0, z=0):
+ """Shift the Point by adding x and y to the coordinates of the Point.
+
+ See Also
+ ========
+
+ scale
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> t = Point3D(0, 1, 1)
+ >>> t.translate(2)
+ Point3D(2, 1, 1)
+ >>> t.translate(2, 2)
+ Point3D(2, 3, 1)
+ >>> t + Point3D(2, 2, 2)
+ Point3D(2, 3, 3)
+
+ """
+ return Point3D(self.x + x, self.y + y, self.z + z)
+
+ @property
+ def coordinates(self):
+ """
+ Returns the three coordinates of the Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> p = Point3D(0, 1, 2)
+ >>> p.coordinates
+ (0, 1, 2)
+ """
+ return self.args
+
+ @property
+ def x(self):
+ """
+ Returns the X coordinate of the Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> p = Point3D(0, 1, 3)
+ >>> p.x
+ 0
+ """
+ return self.args[0]
+
+ @property
+ def y(self):
+ """
+ Returns the Y coordinate of the Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> p = Point3D(0, 1, 2)
+ >>> p.y
+ 1
+ """
+ return self.args[1]
+
+ @property
+ def z(self):
+ """
+ Returns the Z coordinate of the Point.
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D
+ >>> p = Point3D(0, 1, 1)
+ >>> p.z
+ 1
+ """
+ return self.args[2]
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/polygon.py b/janus/lib/python3.10/site-packages/sympy/geometry/polygon.py
new file mode 100644
index 0000000000000000000000000000000000000000..63031183438e2d228f881fd82e1b0ecca04ec534
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/geometry/polygon.py
@@ -0,0 +1,2891 @@
+from sympy.core import Expr, S, oo, pi, sympify
+from sympy.core.evalf import N
+from sympy.core.sorting import default_sort_key, ordered
+from sympy.core.symbol import _symbol, Dummy, Symbol
+from sympy.functions.elementary.complexes import sign
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import cos, sin, tan
+from .ellipse import Circle
+from .entity import GeometryEntity, GeometrySet
+from .exceptions import GeometryError
+from .line import Line, Segment, Ray
+from .point import Point
+from sympy.logic import And
+from sympy.matrices import Matrix
+from sympy.simplify.simplify import simplify
+from sympy.solvers.solvers import solve
+from sympy.utilities.iterables import has_dups, has_variety, uniq, rotate_left, least_rotation
+from sympy.utilities.misc import as_int, func_name
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+import warnings
+
+
+x, y, T = [Dummy('polygon_dummy', real=True) for i in range(3)]
+
+
+class Polygon(GeometrySet):
+ """A two-dimensional polygon.
+
+ A simple polygon in space. Can be constructed from a sequence of points
+ or from a center, radius, number of sides and rotation angle.
+
+ Parameters
+ ==========
+
+ vertices
+ A sequence of points.
+
+ n : int, optional
+ If $> 0$, an n-sided RegularPolygon is created.
+ Default value is $0$.
+
+ Attributes
+ ==========
+
+ area
+ angles
+ perimeter
+ vertices
+ centroid
+ sides
+
+ Raises
+ ======
+
+ GeometryError
+ If all parameters are not Points.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, sympy.geometry.line.Segment, Triangle
+
+ Notes
+ =====
+
+ Polygons are treated as closed paths rather than 2D areas so
+ some calculations can be be negative or positive (e.g., area)
+ based on the orientation of the points.
+
+ Any consecutive identical points are reduced to a single point
+ and any points collinear and between two points will be removed
+ unless they are needed to define an explicit intersection (see examples).
+
+ A Triangle, Segment or Point will be returned when there are 3 or
+ fewer points provided.
+
+ Examples
+ ========
+
+ >>> from sympy import Polygon, pi
+ >>> p1, p2, p3, p4, p5 = [(0, 0), (1, 0), (5, 1), (0, 1), (3, 0)]
+ >>> Polygon(p1, p2, p3, p4)
+ Polygon(Point2D(0, 0), Point2D(1, 0), Point2D(5, 1), Point2D(0, 1))
+ >>> Polygon(p1, p2)
+ Segment2D(Point2D(0, 0), Point2D(1, 0))
+ >>> Polygon(p1, p2, p5)
+ Segment2D(Point2D(0, 0), Point2D(3, 0))
+
+ The area of a polygon is calculated as positive when vertices are
+ traversed in a ccw direction. When the sides of a polygon cross the
+ area will have positive and negative contributions. The following
+ defines a Z shape where the bottom right connects back to the top
+ left.
+
+ >>> Polygon((0, 2), (2, 2), (0, 0), (2, 0)).area
+ 0
+
+ When the keyword `n` is used to define the number of sides of the
+ Polygon then a RegularPolygon is created and the other arguments are
+ interpreted as center, radius and rotation. The unrotated RegularPolygon
+ will always have a vertex at Point(r, 0) where `r` is the radius of the
+ circle that circumscribes the RegularPolygon. Its method `spin` can be
+ used to increment that angle.
+
+ >>> p = Polygon((0,0), 1, n=3)
+ >>> p
+ RegularPolygon(Point2D(0, 0), 1, 3, 0)
+ >>> p.vertices[0]
+ Point2D(1, 0)
+ >>> p.args[0]
+ Point2D(0, 0)
+ >>> p.spin(pi/2)
+ >>> p.vertices[0]
+ Point2D(0, 1)
+
+ """
+
+ __slots__ = ()
+
+ def __new__(cls, *args, n = 0, **kwargs):
+ if n:
+ args = list(args)
+ # return a virtual polygon with n sides
+ if len(args) == 2: # center, radius
+ args.append(n)
+ elif len(args) == 3: # center, radius, rotation
+ args.insert(2, n)
+ return RegularPolygon(*args, **kwargs)
+
+ vertices = [Point(a, dim=2, **kwargs) for a in args]
+
+ # remove consecutive duplicates
+ nodup = []
+ for p in vertices:
+ if nodup and p == nodup[-1]:
+ continue
+ nodup.append(p)
+ if len(nodup) > 1 and nodup[-1] == nodup[0]:
+ nodup.pop() # last point was same as first
+
+ # remove collinear points
+ i = -3
+ while i < len(nodup) - 3 and len(nodup) > 2:
+ a, b, c = nodup[i], nodup[i + 1], nodup[i + 2]
+ if Point.is_collinear(a, b, c):
+ nodup.pop(i + 1)
+ if a == c:
+ nodup.pop(i)
+ else:
+ i += 1
+
+ vertices = list(nodup)
+
+ if len(vertices) > 3:
+ return GeometryEntity.__new__(cls, *vertices, **kwargs)
+ elif len(vertices) == 3:
+ return Triangle(*vertices, **kwargs)
+ elif len(vertices) == 2:
+ return Segment(*vertices, **kwargs)
+ else:
+ return Point(*vertices, **kwargs)
+
+ @property
+ def area(self):
+ """
+ The area of the polygon.
+
+ Notes
+ =====
+
+ The area calculation can be positive or negative based on the
+ orientation of the points. If any side of the polygon crosses
+ any other side, there will be areas having opposite signs.
+
+ See Also
+ ========
+
+ sympy.geometry.ellipse.Ellipse.area
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Polygon
+ >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+ >>> poly = Polygon(p1, p2, p3, p4)
+ >>> poly.area
+ 3
+
+ In the Z shaped polygon (with the lower right connecting back
+ to the upper left) the areas cancel out:
+
+ >>> Z = Polygon((0, 1), (1, 1), (0, 0), (1, 0))
+ >>> Z.area
+ 0
+
+ In the M shaped polygon, areas do not cancel because no side
+ crosses any other (though there is a point of contact).
+
+ >>> M = Polygon((0, 0), (0, 1), (2, 0), (3, 1), (3, 0))
+ >>> M.area
+ -3/2
+
+ """
+ area = 0
+ args = self.args
+ for i in range(len(args)):
+ x1, y1 = args[i - 1].args
+ x2, y2 = args[i].args
+ area += x1*y2 - x2*y1
+ return simplify(area) / 2
+
+ @staticmethod
+ def _is_clockwise(a, b, c):
+ """Return True/False for cw/ccw orientation.
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Polygon
+ >>> a, b, c = [Point(i) for i in [(0, 0), (1, 1), (1, 0)]]
+ >>> Polygon._is_clockwise(a, b, c)
+ True
+ >>> Polygon._is_clockwise(a, c, b)
+ False
+ """
+ ba = b - a
+ ca = c - a
+ t_area = simplify(ba.x*ca.y - ca.x*ba.y)
+ res = t_area.is_nonpositive
+ if res is None:
+ raise ValueError("Can't determine orientation")
+ return res
+
+ @property
+ def angles(self):
+ """The internal angle at each vertex.
+
+ Returns
+ =======
+
+ angles : dict
+ A dictionary where each key is a vertex and each value is the
+ internal angle at that vertex. The vertices are represented as
+ Points.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, sympy.geometry.line.LinearEntity.angle_between
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Polygon
+ >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+ >>> poly = Polygon(p1, p2, p3, p4)
+ >>> poly.angles[p1]
+ pi/2
+ >>> poly.angles[p2]
+ acos(-4*sqrt(17)/17)
+
+ """
+
+ args = self.vertices
+ n = len(args)
+ ret = {}
+ for i in range(n):
+ a, b, c = args[i - 2], args[i - 1], args[i]
+ reflex_ang = Ray(b, a).angle_between(Ray(b, c))
+ if self._is_clockwise(a, b, c):
+ ret[b] = 2*S.Pi - reflex_ang
+ else:
+ ret[b] = reflex_ang
+
+ # internal sum should be pi*(n - 2), not pi*(n+2)
+ # so if ratio is (n+2)/(n-2) > 1 it is wrong
+ wrong = ((sum(ret.values())/S.Pi-1)/(n - 2) - 1).is_positive
+ if wrong:
+ two_pi = 2*S.Pi
+ for b in ret:
+ ret[b] = two_pi - ret[b]
+ elif wrong is None:
+ raise ValueError("could not determine Polygon orientation.")
+ return ret
+
+ @property
+ def ambient_dimension(self):
+ return self.vertices[0].ambient_dimension
+
+ @property
+ def perimeter(self):
+ """The perimeter of the polygon.
+
+ Returns
+ =======
+
+ perimeter : number or Basic instance
+
+ See Also
+ ========
+
+ sympy.geometry.line.Segment.length
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Polygon
+ >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+ >>> poly = Polygon(p1, p2, p3, p4)
+ >>> poly.perimeter
+ sqrt(17) + 7
+ """
+ p = 0
+ args = self.vertices
+ for i in range(len(args)):
+ p += args[i - 1].distance(args[i])
+ return simplify(p)
+
+ @property
+ def vertices(self):
+ """The vertices of the polygon.
+
+ Returns
+ =======
+
+ vertices : list of Points
+
+ Notes
+ =====
+
+ When iterating over the vertices, it is more efficient to index self
+ rather than to request the vertices and index them. Only use the
+ vertices when you want to process all of them at once. This is even
+ more important with RegularPolygons that calculate each vertex.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Polygon
+ >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+ >>> poly = Polygon(p1, p2, p3, p4)
+ >>> poly.vertices
+ [Point2D(0, 0), Point2D(1, 0), Point2D(5, 1), Point2D(0, 1)]
+ >>> poly.vertices[0]
+ Point2D(0, 0)
+
+ """
+ return list(self.args)
+
+ @property
+ def centroid(self):
+ """The centroid of the polygon.
+
+ Returns
+ =======
+
+ centroid : Point
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, sympy.geometry.util.centroid
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Polygon
+ >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+ >>> poly = Polygon(p1, p2, p3, p4)
+ >>> poly.centroid
+ Point2D(31/18, 11/18)
+
+ """
+ A = 1/(6*self.area)
+ cx, cy = 0, 0
+ args = self.args
+ for i in range(len(args)):
+ x1, y1 = args[i - 1].args
+ x2, y2 = args[i].args
+ v = x1*y2 - x2*y1
+ cx += v*(x1 + x2)
+ cy += v*(y1 + y2)
+ return Point(simplify(A*cx), simplify(A*cy))
+
+
+ def second_moment_of_area(self, point=None):
+ """Returns the second moment and product moment of area of a two dimensional polygon.
+
+ Parameters
+ ==========
+
+ point : Point, two-tuple of sympifyable objects, or None(default=None)
+ point is the point about which second moment of area is to be found.
+ If "point=None" it will be calculated about the axis passing through the
+ centroid of the polygon.
+
+ Returns
+ =======
+
+ I_xx, I_yy, I_xy : number or SymPy expression
+ I_xx, I_yy are second moment of area of a two dimensional polygon.
+ I_xy is product moment of area of a two dimensional polygon.
+
+ Examples
+ ========
+
+ >>> from sympy import Polygon, symbols
+ >>> a, b = symbols('a, b')
+ >>> p1, p2, p3, p4, p5 = [(0, 0), (a, 0), (a, b), (0, b), (a/3, b/3)]
+ >>> rectangle = Polygon(p1, p2, p3, p4)
+ >>> rectangle.second_moment_of_area()
+ (a*b**3/12, a**3*b/12, 0)
+ >>> rectangle.second_moment_of_area(p5)
+ (a*b**3/9, a**3*b/9, a**2*b**2/36)
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Second_moment_of_area
+
+ """
+
+ I_xx, I_yy, I_xy = 0, 0, 0
+ args = self.vertices
+ for i in range(len(args)):
+ x1, y1 = args[i-1].args
+ x2, y2 = args[i].args
+ v = x1*y2 - x2*y1
+ I_xx += (y1**2 + y1*y2 + y2**2)*v
+ I_yy += (x1**2 + x1*x2 + x2**2)*v
+ I_xy += (x1*y2 + 2*x1*y1 + 2*x2*y2 + x2*y1)*v
+ A = self.area
+ c_x = self.centroid[0]
+ c_y = self.centroid[1]
+ # parallel axis theorem
+ I_xx_c = (I_xx/12) - (A*(c_y**2))
+ I_yy_c = (I_yy/12) - (A*(c_x**2))
+ I_xy_c = (I_xy/24) - (A*(c_x*c_y))
+ if point is None:
+ return I_xx_c, I_yy_c, I_xy_c
+
+ I_xx = (I_xx_c + A*((point[1]-c_y)**2))
+ I_yy = (I_yy_c + A*((point[0]-c_x)**2))
+ I_xy = (I_xy_c + A*((point[0]-c_x)*(point[1]-c_y)))
+
+ return I_xx, I_yy, I_xy
+
+
+ def first_moment_of_area(self, point=None):
+ """
+ Returns the first moment of area of a two-dimensional polygon with
+ respect to a certain point of interest.
+
+ First moment of area is a measure of the distribution of the area
+ of a polygon in relation to an axis. The first moment of area of
+ the entire polygon about its own centroid is always zero. Therefore,
+ here it is calculated for an area, above or below a certain point
+ of interest, that makes up a smaller portion of the polygon. This
+ area is bounded by the point of interest and the extreme end
+ (top or bottom) of the polygon. The first moment for this area is
+ is then determined about the centroidal axis of the initial polygon.
+
+ References
+ ==========
+
+ .. [1] https://skyciv.com/docs/tutorials/section-tutorials/calculating-the-statical-or-first-moment-of-area-of-beam-sections/?cc=BMD
+ .. [2] https://mechanicalc.com/reference/cross-sections
+
+ Parameters
+ ==========
+
+ point: Point, two-tuple of sympifyable objects, or None (default=None)
+ point is the point above or below which the area of interest lies
+ If ``point=None`` then the centroid acts as the point of interest.
+
+ Returns
+ =======
+
+ Q_x, Q_y: number or SymPy expressions
+ Q_x is the first moment of area about the x-axis
+ Q_y is the first moment of area about the y-axis
+ A negative sign indicates that the section modulus is
+ determined for a section below (or left of) the centroidal axis
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Polygon
+ >>> a, b = 50, 10
+ >>> p1, p2, p3, p4 = [(0, b), (0, 0), (a, 0), (a, b)]
+ >>> p = Polygon(p1, p2, p3, p4)
+ >>> p.first_moment_of_area()
+ (625, 3125)
+ >>> p.first_moment_of_area(point=Point(30, 7))
+ (525, 3000)
+ """
+ if point:
+ xc, yc = self.centroid
+ else:
+ point = self.centroid
+ xc, yc = point
+
+ h_line = Line(point, slope=0)
+ v_line = Line(point, slope=S.Infinity)
+
+ h_poly = self.cut_section(h_line)
+ v_poly = self.cut_section(v_line)
+
+ poly_1 = h_poly[0] if h_poly[0].area <= h_poly[1].area else h_poly[1]
+ poly_2 = v_poly[0] if v_poly[0].area <= v_poly[1].area else v_poly[1]
+
+ Q_x = (poly_1.centroid.y - yc)*poly_1.area
+ Q_y = (poly_2.centroid.x - xc)*poly_2.area
+
+ return Q_x, Q_y
+
+
+ def polar_second_moment_of_area(self):
+ """Returns the polar modulus of a two-dimensional polygon
+
+ It is a constituent of the second moment of area, linked through
+ the perpendicular axis theorem. While the planar second moment of
+ area describes an object's resistance to deflection (bending) when
+ subjected to a force applied to a plane parallel to the central
+ axis, the polar second moment of area describes an object's
+ resistance to deflection when subjected to a moment applied in a
+ plane perpendicular to the object's central axis (i.e. parallel to
+ the cross-section)
+
+ Examples
+ ========
+
+ >>> from sympy import Polygon, symbols
+ >>> a, b = symbols('a, b')
+ >>> rectangle = Polygon((0, 0), (a, 0), (a, b), (0, b))
+ >>> rectangle.polar_second_moment_of_area()
+ a**3*b/12 + a*b**3/12
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Polar_moment_of_inertia
+
+ """
+ second_moment = self.second_moment_of_area()
+ return second_moment[0] + second_moment[1]
+
+
+ def section_modulus(self, point=None):
+ """Returns a tuple with the section modulus of a two-dimensional
+ polygon.
+
+ Section modulus is a geometric property of a polygon defined as the
+ ratio of second moment of area to the distance of the extreme end of
+ the polygon from the centroidal axis.
+
+ Parameters
+ ==========
+
+ point : Point, two-tuple of sympifyable objects, or None(default=None)
+ point is the point at which section modulus is to be found.
+ If "point=None" it will be calculated for the point farthest from the
+ centroidal axis of the polygon.
+
+ Returns
+ =======
+
+ S_x, S_y: numbers or SymPy expressions
+ S_x is the section modulus with respect to the x-axis
+ S_y is the section modulus with respect to the y-axis
+ A negative sign indicates that the section modulus is
+ determined for a point below the centroidal axis
+
+ Examples
+ ========
+
+ >>> from sympy import symbols, Polygon, Point
+ >>> a, b = symbols('a, b', positive=True)
+ >>> rectangle = Polygon((0, 0), (a, 0), (a, b), (0, b))
+ >>> rectangle.section_modulus()
+ (a*b**2/6, a**2*b/6)
+ >>> rectangle.section_modulus(Point(a/4, b/4))
+ (-a*b**2/3, -a**2*b/3)
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Section_modulus
+
+ """
+ x_c, y_c = self.centroid
+ if point is None:
+ # taking x and y as maximum distances from centroid
+ x_min, y_min, x_max, y_max = self.bounds
+ y = max(y_c - y_min, y_max - y_c)
+ x = max(x_c - x_min, x_max - x_c)
+ else:
+ # taking x and y as distances of the given point from the centroid
+ y = point.y - y_c
+ x = point.x - x_c
+
+ second_moment= self.second_moment_of_area()
+ S_x = second_moment[0]/y
+ S_y = second_moment[1]/x
+
+ return S_x, S_y
+
+
+ @property
+ def sides(self):
+ """The directed line segments that form the sides of the polygon.
+
+ Returns
+ =======
+
+ sides : list of sides
+ Each side is a directed Segment.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, sympy.geometry.line.Segment
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Polygon
+ >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+ >>> poly = Polygon(p1, p2, p3, p4)
+ >>> poly.sides
+ [Segment2D(Point2D(0, 0), Point2D(1, 0)),
+ Segment2D(Point2D(1, 0), Point2D(5, 1)),
+ Segment2D(Point2D(5, 1), Point2D(0, 1)), Segment2D(Point2D(0, 1), Point2D(0, 0))]
+
+ """
+ res = []
+ args = self.vertices
+ for i in range(-len(args), 0):
+ res.append(Segment(args[i], args[i + 1]))
+ return res
+
+ @property
+ def bounds(self):
+ """Return a tuple (xmin, ymin, xmax, ymax) representing the bounding
+ rectangle for the geometric figure.
+
+ """
+
+ verts = self.vertices
+ xs = [p.x for p in verts]
+ ys = [p.y for p in verts]
+ return (min(xs), min(ys), max(xs), max(ys))
+
+ def is_convex(self):
+ """Is the polygon convex?
+
+ A polygon is convex if all its interior angles are less than 180
+ degrees and there are no intersections between sides.
+
+ Returns
+ =======
+
+ is_convex : boolean
+ True if this polygon is convex, False otherwise.
+
+ See Also
+ ========
+
+ sympy.geometry.util.convex_hull
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Polygon
+ >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+ >>> poly = Polygon(p1, p2, p3, p4)
+ >>> poly.is_convex()
+ True
+
+ """
+ # Determine orientation of points
+ args = self.vertices
+ cw = self._is_clockwise(args[-2], args[-1], args[0])
+ for i in range(1, len(args)):
+ if cw ^ self._is_clockwise(args[i - 2], args[i - 1], args[i]):
+ return False
+ # check for intersecting sides
+ sides = self.sides
+ for i, si in enumerate(sides):
+ pts = si.args
+ # exclude the sides connected to si
+ for j in range(1 if i == len(sides) - 1 else 0, i - 1):
+ sj = sides[j]
+ if sj.p1 not in pts and sj.p2 not in pts:
+ hit = si.intersection(sj)
+ if hit:
+ return False
+ return True
+
+ def encloses_point(self, p):
+ """
+ Return True if p is enclosed by (is inside of) self.
+
+ Notes
+ =====
+
+ Being on the border of self is considered False.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ encloses_point : True, False or None
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, sympy.geometry.ellipse.Ellipse.encloses_point
+
+ Examples
+ ========
+
+ >>> from sympy import Polygon, Point
+ >>> p = Polygon((0, 0), (4, 0), (4, 4))
+ >>> p.encloses_point(Point(2, 1))
+ True
+ >>> p.encloses_point(Point(2, 2))
+ False
+ >>> p.encloses_point(Point(5, 5))
+ False
+
+ References
+ ==========
+
+ .. [1] https://paulbourke.net/geometry/polygonmesh/#insidepoly
+
+ """
+ p = Point(p, dim=2)
+ if p in self.vertices or any(p in s for s in self.sides):
+ return False
+
+ # move to p, checking that the result is numeric
+ lit = []
+ for v in self.vertices:
+ lit.append(v - p) # the difference is simplified
+ if lit[-1].free_symbols:
+ return None
+
+ poly = Polygon(*lit)
+
+ # polygon closure is assumed in the following test but Polygon removes duplicate pts so
+ # the last point has to be added so all sides are computed. Using Polygon.sides is
+ # not good since Segments are unordered.
+ args = poly.args
+ indices = list(range(-len(args), 1))
+
+ if poly.is_convex():
+ orientation = None
+ for i in indices:
+ a = args[i]
+ b = args[i + 1]
+ test = ((-a.y)*(b.x - a.x) - (-a.x)*(b.y - a.y)).is_negative
+ if orientation is None:
+ orientation = test
+ elif test is not orientation:
+ return False
+ return True
+
+ hit_odd = False
+ p1x, p1y = args[0].args
+ for i in indices[1:]:
+ p2x, p2y = args[i].args
+ if 0 > min(p1y, p2y):
+ if 0 <= max(p1y, p2y):
+ if 0 <= max(p1x, p2x):
+ if p1y != p2y:
+ xinters = (-p1y)*(p2x - p1x)/(p2y - p1y) + p1x
+ if p1x == p2x or 0 <= xinters:
+ hit_odd = not hit_odd
+ p1x, p1y = p2x, p2y
+ return hit_odd
+
+ def arbitrary_point(self, parameter='t'):
+ """A parameterized point on the polygon.
+
+ The parameter, varying from 0 to 1, assigns points to the position on
+ the perimeter that is that fraction of the total perimeter. So the
+ point evaluated at t=1/2 would return the point from the first vertex
+ that is 1/2 way around the polygon.
+
+ Parameters
+ ==========
+
+ parameter : str, optional
+ Default value is 't'.
+
+ Returns
+ =======
+
+ arbitrary_point : Point
+
+ Raises
+ ======
+
+ ValueError
+ When `parameter` already appears in the Polygon's definition.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Polygon, Symbol
+ >>> t = Symbol('t', real=True)
+ >>> tri = Polygon((0, 0), (1, 0), (1, 1))
+ >>> p = tri.arbitrary_point('t')
+ >>> perimeter = tri.perimeter
+ >>> s1, s2 = [s.length for s in tri.sides[:2]]
+ >>> p.subs(t, (s1 + s2/2)/perimeter)
+ Point2D(1, 1/2)
+
+ """
+ t = _symbol(parameter, real=True)
+ if t.name in (f.name for f in self.free_symbols):
+ raise ValueError('Symbol %s already appears in object and cannot be used as a parameter.' % t.name)
+ sides = []
+ perimeter = self.perimeter
+ perim_fraction_start = 0
+ for s in self.sides:
+ side_perim_fraction = s.length/perimeter
+ perim_fraction_end = perim_fraction_start + side_perim_fraction
+ pt = s.arbitrary_point(parameter).subs(
+ t, (t - perim_fraction_start)/side_perim_fraction)
+ sides.append(
+ (pt, (And(perim_fraction_start <= t, t < perim_fraction_end))))
+ perim_fraction_start = perim_fraction_end
+ return Piecewise(*sides)
+
+ def parameter_value(self, other, t):
+ if not isinstance(other,GeometryEntity):
+ other = Point(other, dim=self.ambient_dimension)
+ if not isinstance(other,Point):
+ raise ValueError("other must be a point")
+ if other.free_symbols:
+ raise NotImplementedError('non-numeric coordinates')
+ unknown = False
+ p = self.arbitrary_point(T)
+ for pt, cond in p.args:
+ sol = solve(pt - other, T, dict=True)
+ if not sol:
+ continue
+ value = sol[0][T]
+ if simplify(cond.subs(T, value)) == True:
+ return {t: value}
+ unknown = True
+ if unknown:
+ raise ValueError("Given point may not be on %s" % func_name(self))
+ raise ValueError("Given point is not on %s" % func_name(self))
+
+ def plot_interval(self, parameter='t'):
+ """The plot interval for the default geometric plot of the polygon.
+
+ Parameters
+ ==========
+
+ parameter : str, optional
+ Default value is 't'.
+
+ Returns
+ =======
+
+ plot_interval : list (plot interval)
+ [parameter, lower_bound, upper_bound]
+
+ Examples
+ ========
+
+ >>> from sympy import Polygon
+ >>> p = Polygon((0, 0), (1, 0), (1, 1))
+ >>> p.plot_interval()
+ [t, 0, 1]
+
+ """
+ t = Symbol(parameter, real=True)
+ return [t, 0, 1]
+
+ def intersection(self, o):
+ """The intersection of polygon and geometry entity.
+
+ The intersection may be empty and can contain individual Points and
+ complete Line Segments.
+
+ Parameters
+ ==========
+
+ other: GeometryEntity
+
+ Returns
+ =======
+
+ intersection : list
+ The list of Segments and Points
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, sympy.geometry.line.Segment
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Polygon, Line
+ >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+ >>> poly1 = Polygon(p1, p2, p3, p4)
+ >>> p5, p6, p7 = map(Point, [(3, 2), (1, -1), (0, 2)])
+ >>> poly2 = Polygon(p5, p6, p7)
+ >>> poly1.intersection(poly2)
+ [Point2D(1/3, 1), Point2D(2/3, 0), Point2D(9/5, 1/5), Point2D(7/3, 1)]
+ >>> poly1.intersection(Line(p1, p2))
+ [Segment2D(Point2D(0, 0), Point2D(1, 0))]
+ >>> poly1.intersection(p1)
+ [Point2D(0, 0)]
+ """
+ intersection_result = []
+ k = o.sides if isinstance(o, Polygon) else [o]
+ for side in self.sides:
+ for side1 in k:
+ intersection_result.extend(side.intersection(side1))
+
+ intersection_result = list(uniq(intersection_result))
+ points = [entity for entity in intersection_result if isinstance(entity, Point)]
+ segments = [entity for entity in intersection_result if isinstance(entity, Segment)]
+
+ if points and segments:
+ points_in_segments = list(uniq([point for point in points for segment in segments if point in segment]))
+ if points_in_segments:
+ for i in points_in_segments:
+ points.remove(i)
+ return list(ordered(segments + points))
+ else:
+ return list(ordered(intersection_result))
+
+
+ def cut_section(self, line):
+ """
+ Returns a tuple of two polygon segments that lie above and below
+ the intersecting line respectively.
+
+ Parameters
+ ==========
+
+ line: Line object of geometry module
+ line which cuts the Polygon. The part of the Polygon that lies
+ above and below this line is returned.
+
+ Returns
+ =======
+
+ upper_polygon, lower_polygon: Polygon objects or None
+ upper_polygon is the polygon that lies above the given line.
+ lower_polygon is the polygon that lies below the given line.
+ upper_polygon and lower polygon are ``None`` when no polygon
+ exists above the line or below the line.
+
+ Raises
+ ======
+
+ ValueError: When the line does not intersect the polygon
+
+ Examples
+ ========
+
+ >>> from sympy import Polygon, Line
+ >>> a, b = 20, 10
+ >>> p1, p2, p3, p4 = [(0, b), (0, 0), (a, 0), (a, b)]
+ >>> rectangle = Polygon(p1, p2, p3, p4)
+ >>> t = rectangle.cut_section(Line((0, 5), slope=0))
+ >>> t
+ (Polygon(Point2D(0, 10), Point2D(0, 5), Point2D(20, 5), Point2D(20, 10)),
+ Polygon(Point2D(0, 5), Point2D(0, 0), Point2D(20, 0), Point2D(20, 5)))
+ >>> upper_segment, lower_segment = t
+ >>> upper_segment.area
+ 100
+ >>> upper_segment.centroid
+ Point2D(10, 15/2)
+ >>> lower_segment.centroid
+ Point2D(10, 5/2)
+
+ References
+ ==========
+
+ .. [1] https://github.com/sympy/sympy/wiki/A-method-to-return-a-cut-section-of-any-polygon-geometry
+
+ """
+ intersection_points = self.intersection(line)
+ if not intersection_points:
+ raise ValueError("This line does not intersect the polygon")
+
+ points = list(self.vertices)
+ points.append(points[0])
+
+ eq = line.equation(x, y)
+
+ # considering equation of line to be `ax +by + c`
+ a = eq.coeff(x)
+ b = eq.coeff(y)
+
+ upper_vertices = []
+ lower_vertices = []
+ # prev is true when previous point is above the line
+ prev = True
+ prev_point = None
+ for point in points:
+ # when coefficient of y is 0, right side of the line is
+ # considered
+ compare = eq.subs({x: point.x, y: point.y})/b if b \
+ else eq.subs(x, point.x)/a
+
+ # if point lies above line
+ if compare > 0:
+ if not prev:
+ # if previous point lies below the line, the intersection
+ # point of the polygon edge and the line has to be included
+ edge = Line(point, prev_point)
+ new_point = edge.intersection(line)
+ upper_vertices.append(new_point[0])
+ lower_vertices.append(new_point[0])
+
+ upper_vertices.append(point)
+ prev = True
+ else:
+ if prev and prev_point:
+ edge = Line(point, prev_point)
+ new_point = edge.intersection(line)
+ upper_vertices.append(new_point[0])
+ lower_vertices.append(new_point[0])
+ lower_vertices.append(point)
+ prev = False
+ prev_point = point
+
+ upper_polygon, lower_polygon = None, None
+ if upper_vertices and isinstance(Polygon(*upper_vertices), Polygon):
+ upper_polygon = Polygon(*upper_vertices)
+ if lower_vertices and isinstance(Polygon(*lower_vertices), Polygon):
+ lower_polygon = Polygon(*lower_vertices)
+
+ return upper_polygon, lower_polygon
+
+
+ def distance(self, o):
+ """
+ Returns the shortest distance between self and o.
+
+ If o is a point, then self does not need to be convex.
+ If o is another polygon self and o must be convex.
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Polygon, RegularPolygon
+ >>> p1, p2 = map(Point, [(0, 0), (7, 5)])
+ >>> poly = Polygon(*RegularPolygon(p1, 1, 3).vertices)
+ >>> poly.distance(p2)
+ sqrt(61)
+ """
+ if isinstance(o, Point):
+ dist = oo
+ for side in self.sides:
+ current = side.distance(o)
+ if current == 0:
+ return S.Zero
+ elif current < dist:
+ dist = current
+ return dist
+ elif isinstance(o, Polygon) and self.is_convex() and o.is_convex():
+ return self._do_poly_distance(o)
+ raise NotImplementedError()
+
+ def _do_poly_distance(self, e2):
+ """
+ Calculates the least distance between the exteriors of two
+ convex polygons e1 and e2. Does not check for the convexity
+ of the polygons as this is checked by Polygon.distance.
+
+ Notes
+ =====
+
+ - Prints a warning if the two polygons possibly intersect as the return
+ value will not be valid in such a case. For a more through test of
+ intersection use intersection().
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point.distance
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Polygon
+ >>> square = Polygon(Point(0, 0), Point(0, 1), Point(1, 1), Point(1, 0))
+ >>> triangle = Polygon(Point(1, 2), Point(2, 2), Point(2, 1))
+ >>> square._do_poly_distance(triangle)
+ sqrt(2)/2
+
+ Description of method used
+ ==========================
+
+ Method:
+ [1] https://web.archive.org/web/20150509035744/http://cgm.cs.mcgill.ca/~orm/mind2p.html
+ Uses rotating calipers:
+ [2] https://en.wikipedia.org/wiki/Rotating_calipers
+ and antipodal points:
+ [3] https://en.wikipedia.org/wiki/Antipodal_point
+ """
+ e1 = self
+
+ '''Tests for a possible intersection between the polygons and outputs a warning'''
+ e1_center = e1.centroid
+ e2_center = e2.centroid
+ e1_max_radius = S.Zero
+ e2_max_radius = S.Zero
+ for vertex in e1.vertices:
+ r = Point.distance(e1_center, vertex)
+ if e1_max_radius < r:
+ e1_max_radius = r
+ for vertex in e2.vertices:
+ r = Point.distance(e2_center, vertex)
+ if e2_max_radius < r:
+ e2_max_radius = r
+ center_dist = Point.distance(e1_center, e2_center)
+ if center_dist <= e1_max_radius + e2_max_radius:
+ warnings.warn("Polygons may intersect producing erroneous output",
+ stacklevel=3)
+
+ '''
+ Find the upper rightmost vertex of e1 and the lowest leftmost vertex of e2
+ '''
+ e1_ymax = Point(0, -oo)
+ e2_ymin = Point(0, oo)
+
+ for vertex in e1.vertices:
+ if vertex.y > e1_ymax.y or (vertex.y == e1_ymax.y and vertex.x > e1_ymax.x):
+ e1_ymax = vertex
+ for vertex in e2.vertices:
+ if vertex.y < e2_ymin.y or (vertex.y == e2_ymin.y and vertex.x < e2_ymin.x):
+ e2_ymin = vertex
+ min_dist = Point.distance(e1_ymax, e2_ymin)
+
+ '''
+ Produce a dictionary with vertices of e1 as the keys and, for each vertex, the points
+ to which the vertex is connected as its value. The same is then done for e2.
+ '''
+ e1_connections = {}
+ e2_connections = {}
+
+ for side in e1.sides:
+ if side.p1 in e1_connections:
+ e1_connections[side.p1].append(side.p2)
+ else:
+ e1_connections[side.p1] = [side.p2]
+
+ if side.p2 in e1_connections:
+ e1_connections[side.p2].append(side.p1)
+ else:
+ e1_connections[side.p2] = [side.p1]
+
+ for side in e2.sides:
+ if side.p1 in e2_connections:
+ e2_connections[side.p1].append(side.p2)
+ else:
+ e2_connections[side.p1] = [side.p2]
+
+ if side.p2 in e2_connections:
+ e2_connections[side.p2].append(side.p1)
+ else:
+ e2_connections[side.p2] = [side.p1]
+
+ e1_current = e1_ymax
+ e2_current = e2_ymin
+ support_line = Line(Point(S.Zero, S.Zero), Point(S.One, S.Zero))
+
+ '''
+ Determine which point in e1 and e2 will be selected after e2_ymin and e1_ymax,
+ this information combined with the above produced dictionaries determines the
+ path that will be taken around the polygons
+ '''
+ point1 = e1_connections[e1_ymax][0]
+ point2 = e1_connections[e1_ymax][1]
+ angle1 = support_line.angle_between(Line(e1_ymax, point1))
+ angle2 = support_line.angle_between(Line(e1_ymax, point2))
+ if angle1 < angle2:
+ e1_next = point1
+ elif angle2 < angle1:
+ e1_next = point2
+ elif Point.distance(e1_ymax, point1) > Point.distance(e1_ymax, point2):
+ e1_next = point2
+ else:
+ e1_next = point1
+
+ point1 = e2_connections[e2_ymin][0]
+ point2 = e2_connections[e2_ymin][1]
+ angle1 = support_line.angle_between(Line(e2_ymin, point1))
+ angle2 = support_line.angle_between(Line(e2_ymin, point2))
+ if angle1 > angle2:
+ e2_next = point1
+ elif angle2 > angle1:
+ e2_next = point2
+ elif Point.distance(e2_ymin, point1) > Point.distance(e2_ymin, point2):
+ e2_next = point2
+ else:
+ e2_next = point1
+
+ '''
+ Loop which determines the distance between anti-podal pairs and updates the
+ minimum distance accordingly. It repeats until it reaches the starting position.
+ '''
+ while True:
+ e1_angle = support_line.angle_between(Line(e1_current, e1_next))
+ e2_angle = pi - support_line.angle_between(Line(
+ e2_current, e2_next))
+
+ if (e1_angle < e2_angle) is True:
+ support_line = Line(e1_current, e1_next)
+ e1_segment = Segment(e1_current, e1_next)
+ min_dist_current = e1_segment.distance(e2_current)
+
+ if min_dist_current.evalf() < min_dist.evalf():
+ min_dist = min_dist_current
+
+ if e1_connections[e1_next][0] != e1_current:
+ e1_current = e1_next
+ e1_next = e1_connections[e1_next][0]
+ else:
+ e1_current = e1_next
+ e1_next = e1_connections[e1_next][1]
+ elif (e1_angle > e2_angle) is True:
+ support_line = Line(e2_next, e2_current)
+ e2_segment = Segment(e2_current, e2_next)
+ min_dist_current = e2_segment.distance(e1_current)
+
+ if min_dist_current.evalf() < min_dist.evalf():
+ min_dist = min_dist_current
+
+ if e2_connections[e2_next][0] != e2_current:
+ e2_current = e2_next
+ e2_next = e2_connections[e2_next][0]
+ else:
+ e2_current = e2_next
+ e2_next = e2_connections[e2_next][1]
+ else:
+ support_line = Line(e1_current, e1_next)
+ e1_segment = Segment(e1_current, e1_next)
+ e2_segment = Segment(e2_current, e2_next)
+ min1 = e1_segment.distance(e2_next)
+ min2 = e2_segment.distance(e1_next)
+
+ min_dist_current = min(min1, min2)
+ if min_dist_current.evalf() < min_dist.evalf():
+ min_dist = min_dist_current
+
+ if e1_connections[e1_next][0] != e1_current:
+ e1_current = e1_next
+ e1_next = e1_connections[e1_next][0]
+ else:
+ e1_current = e1_next
+ e1_next = e1_connections[e1_next][1]
+
+ if e2_connections[e2_next][0] != e2_current:
+ e2_current = e2_next
+ e2_next = e2_connections[e2_next][0]
+ else:
+ e2_current = e2_next
+ e2_next = e2_connections[e2_next][1]
+ if e1_current == e1_ymax and e2_current == e2_ymin:
+ break
+ return min_dist
+
+ def _svg(self, scale_factor=1., fill_color="#66cc99"):
+ """Returns SVG path element for the Polygon.
+
+ Parameters
+ ==========
+
+ scale_factor : float
+ Multiplication factor for the SVG stroke-width. Default is 1.
+ fill_color : str, optional
+ Hex string for fill color. Default is "#66cc99".
+ """
+ verts = map(N, self.vertices)
+ coords = ["{},{}".format(p.x, p.y) for p in verts]
+ path = "M {} L {} z".format(coords[0], " L ".join(coords[1:]))
+ return (
+ ''
+ ).format(2. * scale_factor, path, fill_color)
+
+ def _hashable_content(self):
+
+ D = {}
+ def ref_list(point_list):
+ kee = {}
+ for i, p in enumerate(ordered(set(point_list))):
+ kee[p] = i
+ D[i] = p
+ return [kee[p] for p in point_list]
+
+ S1 = ref_list(self.args)
+ r_nor = rotate_left(S1, least_rotation(S1))
+ S2 = ref_list(list(reversed(self.args)))
+ r_rev = rotate_left(S2, least_rotation(S2))
+ if r_nor < r_rev:
+ r = r_nor
+ else:
+ r = r_rev
+ canonical_args = [ D[order] for order in r ]
+ return tuple(canonical_args)
+
+ def __contains__(self, o):
+ """
+ Return True if o is contained within the boundary lines of self.altitudes
+
+ Parameters
+ ==========
+
+ other : GeometryEntity
+
+ Returns
+ =======
+
+ contained in : bool
+ The points (and sides, if applicable) are contained in self.
+
+ See Also
+ ========
+
+ sympy.geometry.entity.GeometryEntity.encloses
+
+ Examples
+ ========
+
+ >>> from sympy import Line, Segment, Point
+ >>> p = Point(0, 0)
+ >>> q = Point(1, 1)
+ >>> s = Segment(p, q*2)
+ >>> l = Line(p, q)
+ >>> p in q
+ False
+ >>> p in s
+ True
+ >>> q*3 in s
+ False
+ >>> s in l
+ True
+
+ """
+
+ if isinstance(o, Polygon):
+ return self == o
+ elif isinstance(o, Segment):
+ return any(o in s for s in self.sides)
+ elif isinstance(o, Point):
+ if o in self.vertices:
+ return True
+ for side in self.sides:
+ if o in side:
+ return True
+
+ return False
+
+ def bisectors(p, prec=None):
+ """Returns angle bisectors of a polygon. If prec is given
+ then approximate the point defining the ray to that precision.
+
+ The distance between the points defining the bisector ray is 1.
+
+ Examples
+ ========
+
+ >>> from sympy import Polygon, Point
+ >>> p = Polygon(Point(0, 0), Point(2, 0), Point(1, 1), Point(0, 3))
+ >>> p.bisectors(2)
+ {Point2D(0, 0): Ray2D(Point2D(0, 0), Point2D(0.71, 0.71)),
+ Point2D(0, 3): Ray2D(Point2D(0, 3), Point2D(0.23, 2.0)),
+ Point2D(1, 1): Ray2D(Point2D(1, 1), Point2D(0.19, 0.42)),
+ Point2D(2, 0): Ray2D(Point2D(2, 0), Point2D(1.1, 0.38))}
+ """
+ b = {}
+ pts = list(p.args)
+ pts.append(pts[0]) # close it
+ cw = Polygon._is_clockwise(*pts[:3])
+ if cw:
+ pts = list(reversed(pts))
+ for v, a in p.angles.items():
+ i = pts.index(v)
+ p1, p2 = Point._normalize_dimension(pts[i], pts[i + 1])
+ ray = Ray(p1, p2).rotate(a/2, v)
+ dir = ray.direction
+ ray = Ray(ray.p1, ray.p1 + dir/dir.distance((0, 0)))
+ if prec is not None:
+ ray = Ray(ray.p1, ray.p2.n(prec))
+ b[v] = ray
+ return b
+
+
+class RegularPolygon(Polygon):
+ """
+ A regular polygon.
+
+ Such a polygon has all internal angles equal and all sides the same length.
+
+ Parameters
+ ==========
+
+ center : Point
+ radius : number or Basic instance
+ The distance from the center to a vertex
+ n : int
+ The number of sides
+
+ Attributes
+ ==========
+
+ vertices
+ center
+ radius
+ rotation
+ apothem
+ interior_angle
+ exterior_angle
+ circumcircle
+ incircle
+ angles
+
+ Raises
+ ======
+
+ GeometryError
+ If the `center` is not a Point, or the `radius` is not a number or Basic
+ instance, or the number of sides, `n`, is less than three.
+
+ Notes
+ =====
+
+ A RegularPolygon can be instantiated with Polygon with the kwarg n.
+
+ Regular polygons are instantiated with a center, radius, number of sides
+ and a rotation angle. Whereas the arguments of a Polygon are vertices, the
+ vertices of the RegularPolygon must be obtained with the vertices method.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, Polygon
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon, Point
+ >>> r = RegularPolygon(Point(0, 0), 5, 3)
+ >>> r
+ RegularPolygon(Point2D(0, 0), 5, 3, 0)
+ >>> r.vertices[0]
+ Point2D(5, 0)
+
+ """
+
+ __slots__ = ('_n', '_center', '_radius', '_rot')
+
+ def __new__(self, c, r, n, rot=0, **kwargs):
+ r, n, rot = map(sympify, (r, n, rot))
+ c = Point(c, dim=2, **kwargs)
+ if not isinstance(r, Expr):
+ raise GeometryError("r must be an Expr object, not %s" % r)
+ if n.is_Number:
+ as_int(n) # let an error raise if necessary
+ if n < 3:
+ raise GeometryError("n must be a >= 3, not %s" % n)
+
+ obj = GeometryEntity.__new__(self, c, r, n, **kwargs)
+ obj._n = n
+ obj._center = c
+ obj._radius = r
+ obj._rot = rot % (2*S.Pi/n) if rot.is_number else rot
+ return obj
+
+ def _eval_evalf(self, prec=15, **options):
+ c, r, n, a = self.args
+ dps = prec_to_dps(prec)
+ c, r, a = [i.evalf(n=dps, **options) for i in (c, r, a)]
+ return self.func(c, r, n, a)
+
+ @property
+ def args(self):
+ """
+ Returns the center point, the radius,
+ the number of sides, and the orientation angle.
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon, Point
+ >>> r = RegularPolygon(Point(0, 0), 5, 3)
+ >>> r.args
+ (Point2D(0, 0), 5, 3, 0)
+ """
+ return self._center, self._radius, self._n, self._rot
+
+ def __str__(self):
+ return 'RegularPolygon(%s, %s, %s, %s)' % tuple(self.args)
+
+ def __repr__(self):
+ return 'RegularPolygon(%s, %s, %s, %s)' % tuple(self.args)
+
+ @property
+ def area(self):
+ """Returns the area.
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon
+ >>> square = RegularPolygon((0, 0), 1, 4)
+ >>> square.area
+ 2
+ >>> _ == square.length**2
+ True
+ """
+ c, r, n, rot = self.args
+ return sign(r)*n*self.length**2/(4*tan(pi/n))
+
+ @property
+ def length(self):
+ """Returns the length of the sides.
+
+ The half-length of the side and the apothem form two legs
+ of a right triangle whose hypotenuse is the radius of the
+ regular polygon.
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon
+ >>> from sympy import sqrt
+ >>> s = square_in_unit_circle = RegularPolygon((0, 0), 1, 4)
+ >>> s.length
+ sqrt(2)
+ >>> sqrt((_/2)**2 + s.apothem**2) == s.radius
+ True
+
+ """
+ return self.radius*2*sin(pi/self._n)
+
+ @property
+ def center(self):
+ """The center of the RegularPolygon
+
+ This is also the center of the circumscribing circle.
+
+ Returns
+ =======
+
+ center : Point
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, sympy.geometry.ellipse.Ellipse.center
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon, Point
+ >>> rp = RegularPolygon(Point(0, 0), 5, 4)
+ >>> rp.center
+ Point2D(0, 0)
+ """
+ return self._center
+
+ centroid = center
+
+ @property
+ def circumcenter(self):
+ """
+ Alias for center.
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon, Point
+ >>> rp = RegularPolygon(Point(0, 0), 5, 4)
+ >>> rp.circumcenter
+ Point2D(0, 0)
+ """
+ return self.center
+
+ @property
+ def radius(self):
+ """Radius of the RegularPolygon
+
+ This is also the radius of the circumscribing circle.
+
+ Returns
+ =======
+
+ radius : number or instance of Basic
+
+ See Also
+ ========
+
+ sympy.geometry.line.Segment.length, sympy.geometry.ellipse.Circle.radius
+
+ Examples
+ ========
+
+ >>> from sympy import Symbol
+ >>> from sympy import RegularPolygon, Point
+ >>> radius = Symbol('r')
+ >>> rp = RegularPolygon(Point(0, 0), radius, 4)
+ >>> rp.radius
+ r
+
+ """
+ return self._radius
+
+ @property
+ def circumradius(self):
+ """
+ Alias for radius.
+
+ Examples
+ ========
+
+ >>> from sympy import Symbol
+ >>> from sympy import RegularPolygon, Point
+ >>> radius = Symbol('r')
+ >>> rp = RegularPolygon(Point(0, 0), radius, 4)
+ >>> rp.circumradius
+ r
+ """
+ return self.radius
+
+ @property
+ def rotation(self):
+ """CCW angle by which the RegularPolygon is rotated
+
+ Returns
+ =======
+
+ rotation : number or instance of Basic
+
+ Examples
+ ========
+
+ >>> from sympy import pi
+ >>> from sympy.abc import a
+ >>> from sympy import RegularPolygon, Point
+ >>> RegularPolygon(Point(0, 0), 3, 4, pi/4).rotation
+ pi/4
+
+ Numerical rotation angles are made canonical:
+
+ >>> RegularPolygon(Point(0, 0), 3, 4, a).rotation
+ a
+ >>> RegularPolygon(Point(0, 0), 3, 4, pi).rotation
+ 0
+
+ """
+ return self._rot
+
+ @property
+ def apothem(self):
+ """The inradius of the RegularPolygon.
+
+ The apothem/inradius is the radius of the inscribed circle.
+
+ Returns
+ =======
+
+ apothem : number or instance of Basic
+
+ See Also
+ ========
+
+ sympy.geometry.line.Segment.length, sympy.geometry.ellipse.Circle.radius
+
+ Examples
+ ========
+
+ >>> from sympy import Symbol
+ >>> from sympy import RegularPolygon, Point
+ >>> radius = Symbol('r')
+ >>> rp = RegularPolygon(Point(0, 0), radius, 4)
+ >>> rp.apothem
+ sqrt(2)*r/2
+
+ """
+ return self.radius * cos(S.Pi/self._n)
+
+ @property
+ def inradius(self):
+ """
+ Alias for apothem.
+
+ Examples
+ ========
+
+ >>> from sympy import Symbol
+ >>> from sympy import RegularPolygon, Point
+ >>> radius = Symbol('r')
+ >>> rp = RegularPolygon(Point(0, 0), radius, 4)
+ >>> rp.inradius
+ sqrt(2)*r/2
+ """
+ return self.apothem
+
+ @property
+ def interior_angle(self):
+ """Measure of the interior angles.
+
+ Returns
+ =======
+
+ interior_angle : number
+
+ See Also
+ ========
+
+ sympy.geometry.line.LinearEntity.angle_between
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon, Point
+ >>> rp = RegularPolygon(Point(0, 0), 4, 8)
+ >>> rp.interior_angle
+ 3*pi/4
+
+ """
+ return (self._n - 2)*S.Pi/self._n
+
+ @property
+ def exterior_angle(self):
+ """Measure of the exterior angles.
+
+ Returns
+ =======
+
+ exterior_angle : number
+
+ See Also
+ ========
+
+ sympy.geometry.line.LinearEntity.angle_between
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon, Point
+ >>> rp = RegularPolygon(Point(0, 0), 4, 8)
+ >>> rp.exterior_angle
+ pi/4
+
+ """
+ return 2*S.Pi/self._n
+
+ @property
+ def circumcircle(self):
+ """The circumcircle of the RegularPolygon.
+
+ Returns
+ =======
+
+ circumcircle : Circle
+
+ See Also
+ ========
+
+ circumcenter, sympy.geometry.ellipse.Circle
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon, Point
+ >>> rp = RegularPolygon(Point(0, 0), 4, 8)
+ >>> rp.circumcircle
+ Circle(Point2D(0, 0), 4)
+
+ """
+ return Circle(self.center, self.radius)
+
+ @property
+ def incircle(self):
+ """The incircle of the RegularPolygon.
+
+ Returns
+ =======
+
+ incircle : Circle
+
+ See Also
+ ========
+
+ inradius, sympy.geometry.ellipse.Circle
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon, Point
+ >>> rp = RegularPolygon(Point(0, 0), 4, 7)
+ >>> rp.incircle
+ Circle(Point2D(0, 0), 4*cos(pi/7))
+
+ """
+ return Circle(self.center, self.apothem)
+
+ @property
+ def angles(self):
+ """
+ Returns a dictionary with keys, the vertices of the Polygon,
+ and values, the interior angle at each vertex.
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon, Point
+ >>> r = RegularPolygon(Point(0, 0), 5, 3)
+ >>> r.angles
+ {Point2D(-5/2, -5*sqrt(3)/2): pi/3,
+ Point2D(-5/2, 5*sqrt(3)/2): pi/3,
+ Point2D(5, 0): pi/3}
+ """
+ ret = {}
+ ang = self.interior_angle
+ for v in self.vertices:
+ ret[v] = ang
+ return ret
+
+ def encloses_point(self, p):
+ """
+ Return True if p is enclosed by (is inside of) self.
+
+ Notes
+ =====
+
+ Being on the border of self is considered False.
+
+ The general Polygon.encloses_point method is called only if
+ a point is not within or beyond the incircle or circumcircle,
+ respectively.
+
+ Parameters
+ ==========
+
+ p : Point
+
+ Returns
+ =======
+
+ encloses_point : True, False or None
+
+ See Also
+ ========
+
+ sympy.geometry.ellipse.Ellipse.encloses_point
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon, S, Point, Symbol
+ >>> p = RegularPolygon((0, 0), 3, 4)
+ >>> p.encloses_point(Point(0, 0))
+ True
+ >>> r, R = p.inradius, p.circumradius
+ >>> p.encloses_point(Point((r + R)/2, 0))
+ True
+ >>> p.encloses_point(Point(R/2, R/2 + (R - r)/10))
+ False
+ >>> t = Symbol('t', real=True)
+ >>> p.encloses_point(p.arbitrary_point().subs(t, S.Half))
+ False
+ >>> p.encloses_point(Point(5, 5))
+ False
+
+ """
+
+ c = self.center
+ d = Segment(c, p).length
+ if d >= self.radius:
+ return False
+ elif d < self.inradius:
+ return True
+ else:
+ # now enumerate the RegularPolygon like a general polygon.
+ return Polygon.encloses_point(self, p)
+
+ def spin(self, angle):
+ """Increment *in place* the virtual Polygon's rotation by ccw angle.
+
+ See also: rotate method which moves the center.
+
+ >>> from sympy import Polygon, Point, pi
+ >>> r = Polygon(Point(0,0), 1, n=3)
+ >>> r.vertices[0]
+ Point2D(1, 0)
+ >>> r.spin(pi/6)
+ >>> r.vertices[0]
+ Point2D(sqrt(3)/2, 1/2)
+
+ See Also
+ ========
+
+ rotation
+ rotate : Creates a copy of the RegularPolygon rotated about a Point
+
+ """
+ self._rot += angle
+
+ def rotate(self, angle, pt=None):
+ """Override GeometryEntity.rotate to first rotate the RegularPolygon
+ about its center.
+
+ >>> from sympy import Point, RegularPolygon, pi
+ >>> t = RegularPolygon(Point(1, 0), 1, 3)
+ >>> t.vertices[0] # vertex on x-axis
+ Point2D(2, 0)
+ >>> t.rotate(pi/2).vertices[0] # vertex on y axis now
+ Point2D(0, 2)
+
+ See Also
+ ========
+
+ rotation
+ spin : Rotates a RegularPolygon in place
+
+ """
+
+ r = type(self)(*self.args) # need a copy or else changes are in-place
+ r._rot += angle
+ return GeometryEntity.rotate(r, angle, pt)
+
+ def scale(self, x=1, y=1, pt=None):
+ """Override GeometryEntity.scale since it is the radius that must be
+ scaled (if x == y) or else a new Polygon must be returned.
+
+ >>> from sympy import RegularPolygon
+
+ Symmetric scaling returns a RegularPolygon:
+
+ >>> RegularPolygon((0, 0), 1, 4).scale(2, 2)
+ RegularPolygon(Point2D(0, 0), 2, 4, 0)
+
+ Asymmetric scaling returns a kite as a Polygon:
+
+ >>> RegularPolygon((0, 0), 1, 4).scale(2, 1)
+ Polygon(Point2D(2, 0), Point2D(0, 1), Point2D(-2, 0), Point2D(0, -1))
+
+ """
+ if pt:
+ pt = Point(pt, dim=2)
+ return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+ if x != y:
+ return Polygon(*self.vertices).scale(x, y)
+ c, r, n, rot = self.args
+ r *= x
+ return self.func(c, r, n, rot)
+
+ def reflect(self, line):
+ """Override GeometryEntity.reflect since this is not made of only
+ points.
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon, Line
+
+ >>> RegularPolygon((0, 0), 1, 4).reflect(Line((0, 1), slope=-2))
+ RegularPolygon(Point2D(4/5, 2/5), -1, 4, atan(4/3))
+
+ """
+ c, r, n, rot = self.args
+ v = self.vertices[0]
+ d = v - c
+ cc = c.reflect(line)
+ vv = v.reflect(line)
+ dd = vv - cc
+ # calculate rotation about the new center
+ # which will align the vertices
+ l1 = Ray((0, 0), dd)
+ l2 = Ray((0, 0), d)
+ ang = l1.closing_angle(l2)
+ rot += ang
+ # change sign of radius as point traversal is reversed
+ return self.func(cc, -r, n, rot)
+
+ @property
+ def vertices(self):
+ """The vertices of the RegularPolygon.
+
+ Returns
+ =======
+
+ vertices : list
+ Each vertex is a Point.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import RegularPolygon, Point
+ >>> rp = RegularPolygon(Point(0, 0), 5, 4)
+ >>> rp.vertices
+ [Point2D(5, 0), Point2D(0, 5), Point2D(-5, 0), Point2D(0, -5)]
+
+ """
+ c = self._center
+ r = abs(self._radius)
+ rot = self._rot
+ v = 2*S.Pi/self._n
+
+ return [Point(c.x + r*cos(k*v + rot), c.y + r*sin(k*v + rot))
+ for k in range(self._n)]
+
+ def __eq__(self, o):
+ if not isinstance(o, Polygon):
+ return False
+ elif not isinstance(o, RegularPolygon):
+ return Polygon.__eq__(o, self)
+ return self.args == o.args
+
+ def __hash__(self):
+ return super().__hash__()
+
+
+class Triangle(Polygon):
+ """
+ A polygon with three vertices and three sides.
+
+ Parameters
+ ==========
+
+ points : sequence of Points
+ keyword: asa, sas, or sss to specify sides/angles of the triangle
+
+ Attributes
+ ==========
+
+ vertices
+ altitudes
+ orthocenter
+ circumcenter
+ circumradius
+ circumcircle
+ inradius
+ incircle
+ exradii
+ medians
+ medial
+ nine_point_circle
+
+ Raises
+ ======
+
+ GeometryError
+ If the number of vertices is not equal to three, or one of the vertices
+ is not a Point, or a valid keyword is not given.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, Polygon
+
+ Examples
+ ========
+
+ >>> from sympy import Triangle, Point
+ >>> Triangle(Point(0, 0), Point(4, 0), Point(4, 3))
+ Triangle(Point2D(0, 0), Point2D(4, 0), Point2D(4, 3))
+
+ Keywords sss, sas, or asa can be used to give the desired
+ side lengths (in order) and interior angles (in degrees) that
+ define the triangle:
+
+ >>> Triangle(sss=(3, 4, 5))
+ Triangle(Point2D(0, 0), Point2D(3, 0), Point2D(3, 4))
+ >>> Triangle(asa=(30, 1, 30))
+ Triangle(Point2D(0, 0), Point2D(1, 0), Point2D(1/2, sqrt(3)/6))
+ >>> Triangle(sas=(1, 45, 2))
+ Triangle(Point2D(0, 0), Point2D(2, 0), Point2D(sqrt(2)/2, sqrt(2)/2))
+
+ """
+
+ def __new__(cls, *args, **kwargs):
+ if len(args) != 3:
+ if 'sss' in kwargs:
+ return _sss(*[simplify(a) for a in kwargs['sss']])
+ if 'asa' in kwargs:
+ return _asa(*[simplify(a) for a in kwargs['asa']])
+ if 'sas' in kwargs:
+ return _sas(*[simplify(a) for a in kwargs['sas']])
+ msg = "Triangle instantiates with three points or a valid keyword."
+ raise GeometryError(msg)
+
+ vertices = [Point(a, dim=2, **kwargs) for a in args]
+
+ # remove consecutive duplicates
+ nodup = []
+ for p in vertices:
+ if nodup and p == nodup[-1]:
+ continue
+ nodup.append(p)
+ if len(nodup) > 1 and nodup[-1] == nodup[0]:
+ nodup.pop() # last point was same as first
+
+ # remove collinear points
+ i = -3
+ while i < len(nodup) - 3 and len(nodup) > 2:
+ a, b, c = sorted(
+ [nodup[i], nodup[i + 1], nodup[i + 2]], key=default_sort_key)
+ if Point.is_collinear(a, b, c):
+ nodup[i] = a
+ nodup[i + 1] = None
+ nodup.pop(i + 1)
+ i += 1
+
+ vertices = list(filter(lambda x: x is not None, nodup))
+
+ if len(vertices) == 3:
+ return GeometryEntity.__new__(cls, *vertices, **kwargs)
+ elif len(vertices) == 2:
+ return Segment(*vertices, **kwargs)
+ else:
+ return Point(*vertices, **kwargs)
+
+ @property
+ def vertices(self):
+ """The triangle's vertices
+
+ Returns
+ =======
+
+ vertices : tuple
+ Each element in the tuple is a Point
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Triangle, Point
+ >>> t = Triangle(Point(0, 0), Point(4, 0), Point(4, 3))
+ >>> t.vertices
+ (Point2D(0, 0), Point2D(4, 0), Point2D(4, 3))
+
+ """
+ return self.args
+
+ def is_similar(t1, t2):
+ """Is another triangle similar to this one.
+
+ Two triangles are similar if one can be uniformly scaled to the other.
+
+ Parameters
+ ==========
+
+ other: Triangle
+
+ Returns
+ =======
+
+ is_similar : boolean
+
+ See Also
+ ========
+
+ sympy.geometry.entity.GeometryEntity.is_similar
+
+ Examples
+ ========
+
+ >>> from sympy import Triangle, Point
+ >>> t1 = Triangle(Point(0, 0), Point(4, 0), Point(4, 3))
+ >>> t2 = Triangle(Point(0, 0), Point(-4, 0), Point(-4, -3))
+ >>> t1.is_similar(t2)
+ True
+
+ >>> t2 = Triangle(Point(0, 0), Point(-4, 0), Point(-4, -4))
+ >>> t1.is_similar(t2)
+ False
+
+ """
+ if not isinstance(t2, Polygon):
+ return False
+
+ s1_1, s1_2, s1_3 = [side.length for side in t1.sides]
+ s2 = [side.length for side in t2.sides]
+
+ def _are_similar(u1, u2, u3, v1, v2, v3):
+ e1 = simplify(u1/v1)
+ e2 = simplify(u2/v2)
+ e3 = simplify(u3/v3)
+ return bool(e1 == e2) and bool(e2 == e3)
+
+ # There's only 6 permutations, so write them out
+ return _are_similar(s1_1, s1_2, s1_3, *s2) or \
+ _are_similar(s1_1, s1_3, s1_2, *s2) or \
+ _are_similar(s1_2, s1_1, s1_3, *s2) or \
+ _are_similar(s1_2, s1_3, s1_1, *s2) or \
+ _are_similar(s1_3, s1_1, s1_2, *s2) or \
+ _are_similar(s1_3, s1_2, s1_1, *s2)
+
+ def is_equilateral(self):
+ """Are all the sides the same length?
+
+ Returns
+ =======
+
+ is_equilateral : boolean
+
+ See Also
+ ========
+
+ sympy.geometry.entity.GeometryEntity.is_similar, RegularPolygon
+ is_isosceles, is_right, is_scalene
+
+ Examples
+ ========
+
+ >>> from sympy import Triangle, Point
+ >>> t1 = Triangle(Point(0, 0), Point(4, 0), Point(4, 3))
+ >>> t1.is_equilateral()
+ False
+
+ >>> from sympy import sqrt
+ >>> t2 = Triangle(Point(0, 0), Point(10, 0), Point(5, 5*sqrt(3)))
+ >>> t2.is_equilateral()
+ True
+
+ """
+ return not has_variety(s.length for s in self.sides)
+
+ def is_isosceles(self):
+ """Are two or more of the sides the same length?
+
+ Returns
+ =======
+
+ is_isosceles : boolean
+
+ See Also
+ ========
+
+ is_equilateral, is_right, is_scalene
+
+ Examples
+ ========
+
+ >>> from sympy import Triangle, Point
+ >>> t1 = Triangle(Point(0, 0), Point(4, 0), Point(2, 4))
+ >>> t1.is_isosceles()
+ True
+
+ """
+ return has_dups(s.length for s in self.sides)
+
+ def is_scalene(self):
+ """Are all the sides of the triangle of different lengths?
+
+ Returns
+ =======
+
+ is_scalene : boolean
+
+ See Also
+ ========
+
+ is_equilateral, is_isosceles, is_right
+
+ Examples
+ ========
+
+ >>> from sympy import Triangle, Point
+ >>> t1 = Triangle(Point(0, 0), Point(4, 0), Point(1, 4))
+ >>> t1.is_scalene()
+ True
+
+ """
+ return not has_dups(s.length for s in self.sides)
+
+ def is_right(self):
+ """Is the triangle right-angled.
+
+ Returns
+ =======
+
+ is_right : boolean
+
+ See Also
+ ========
+
+ sympy.geometry.line.LinearEntity.is_perpendicular
+ is_equilateral, is_isosceles, is_scalene
+
+ Examples
+ ========
+
+ >>> from sympy import Triangle, Point
+ >>> t1 = Triangle(Point(0, 0), Point(4, 0), Point(4, 3))
+ >>> t1.is_right()
+ True
+
+ """
+ s = self.sides
+ return Segment.is_perpendicular(s[0], s[1]) or \
+ Segment.is_perpendicular(s[1], s[2]) or \
+ Segment.is_perpendicular(s[0], s[2])
+
+ @property
+ def altitudes(self):
+ """The altitudes of the triangle.
+
+ An altitude of a triangle is a segment through a vertex,
+ perpendicular to the opposite side, with length being the
+ height of the vertex measured from the line containing the side.
+
+ Returns
+ =======
+
+ altitudes : dict
+ The dictionary consists of keys which are vertices and values
+ which are Segments.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, sympy.geometry.line.Segment.length
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Triangle
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+ >>> t = Triangle(p1, p2, p3)
+ >>> t.altitudes[p1]
+ Segment2D(Point2D(0, 0), Point2D(1/2, 1/2))
+
+ """
+ s = self.sides
+ v = self.vertices
+ return {v[0]: s[1].perpendicular_segment(v[0]),
+ v[1]: s[2].perpendicular_segment(v[1]),
+ v[2]: s[0].perpendicular_segment(v[2])}
+
+ @property
+ def orthocenter(self):
+ """The orthocenter of the triangle.
+
+ The orthocenter is the intersection of the altitudes of a triangle.
+ It may lie inside, outside or on the triangle.
+
+ Returns
+ =======
+
+ orthocenter : Point
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Triangle
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+ >>> t = Triangle(p1, p2, p3)
+ >>> t.orthocenter
+ Point2D(0, 0)
+
+ """
+ a = self.altitudes
+ v = self.vertices
+ return Line(a[v[0]]).intersection(Line(a[v[1]]))[0]
+
+ @property
+ def circumcenter(self):
+ """The circumcenter of the triangle
+
+ The circumcenter is the center of the circumcircle.
+
+ Returns
+ =======
+
+ circumcenter : Point
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Triangle
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+ >>> t = Triangle(p1, p2, p3)
+ >>> t.circumcenter
+ Point2D(1/2, 1/2)
+ """
+ a, b, c = [x.perpendicular_bisector() for x in self.sides]
+ return a.intersection(b)[0]
+
+ @property
+ def circumradius(self):
+ """The radius of the circumcircle of the triangle.
+
+ Returns
+ =======
+
+ circumradius : number of Basic instance
+
+ See Also
+ ========
+
+ sympy.geometry.ellipse.Circle.radius
+
+ Examples
+ ========
+
+ >>> from sympy import Symbol
+ >>> from sympy import Point, Triangle
+ >>> a = Symbol('a')
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, a)
+ >>> t = Triangle(p1, p2, p3)
+ >>> t.circumradius
+ sqrt(a**2/4 + 1/4)
+ """
+ return Point.distance(self.circumcenter, self.vertices[0])
+
+ @property
+ def circumcircle(self):
+ """The circle which passes through the three vertices of the triangle.
+
+ Returns
+ =======
+
+ circumcircle : Circle
+
+ See Also
+ ========
+
+ sympy.geometry.ellipse.Circle
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Triangle
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+ >>> t = Triangle(p1, p2, p3)
+ >>> t.circumcircle
+ Circle(Point2D(1/2, 1/2), sqrt(2)/2)
+
+ """
+ return Circle(self.circumcenter, self.circumradius)
+
+ def bisectors(self):
+ """The angle bisectors of the triangle.
+
+ An angle bisector of a triangle is a straight line through a vertex
+ which cuts the corresponding angle in half.
+
+ Returns
+ =======
+
+ bisectors : dict
+ Each key is a vertex (Point) and each value is the corresponding
+ bisector (Segment).
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, sympy.geometry.line.Segment
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Triangle, Segment
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+ >>> t = Triangle(p1, p2, p3)
+ >>> from sympy import sqrt
+ >>> t.bisectors()[p2] == Segment(Point(1, 0), Point(0, sqrt(2) - 1))
+ True
+
+ """
+ # use lines containing sides so containment check during
+ # intersection calculation can be avoided, thus reducing
+ # the processing time for calculating the bisectors
+ s = [Line(l) for l in self.sides]
+ v = self.vertices
+ c = self.incenter
+ l1 = Segment(v[0], Line(v[0], c).intersection(s[1])[0])
+ l2 = Segment(v[1], Line(v[1], c).intersection(s[2])[0])
+ l3 = Segment(v[2], Line(v[2], c).intersection(s[0])[0])
+ return {v[0]: l1, v[1]: l2, v[2]: l3}
+
+ @property
+ def incenter(self):
+ """The center of the incircle.
+
+ The incircle is the circle which lies inside the triangle and touches
+ all three sides.
+
+ Returns
+ =======
+
+ incenter : Point
+
+ See Also
+ ========
+
+ incircle, sympy.geometry.point.Point
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Triangle
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+ >>> t = Triangle(p1, p2, p3)
+ >>> t.incenter
+ Point2D(1 - sqrt(2)/2, 1 - sqrt(2)/2)
+
+ """
+ s = self.sides
+ l = Matrix([s[i].length for i in [1, 2, 0]])
+ p = sum(l)
+ v = self.vertices
+ x = simplify(l.dot(Matrix([vi.x for vi in v]))/p)
+ y = simplify(l.dot(Matrix([vi.y for vi in v]))/p)
+ return Point(x, y)
+
+ @property
+ def inradius(self):
+ """The radius of the incircle.
+
+ Returns
+ =======
+
+ inradius : number of Basic instance
+
+ See Also
+ ========
+
+ incircle, sympy.geometry.ellipse.Circle.radius
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Triangle
+ >>> p1, p2, p3 = Point(0, 0), Point(4, 0), Point(0, 3)
+ >>> t = Triangle(p1, p2, p3)
+ >>> t.inradius
+ 1
+
+ """
+ return simplify(2 * self.area / self.perimeter)
+
+ @property
+ def incircle(self):
+ """The incircle of the triangle.
+
+ The incircle is the circle which lies inside the triangle and touches
+ all three sides.
+
+ Returns
+ =======
+
+ incircle : Circle
+
+ See Also
+ ========
+
+ sympy.geometry.ellipse.Circle
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Triangle
+ >>> p1, p2, p3 = Point(0, 0), Point(2, 0), Point(0, 2)
+ >>> t = Triangle(p1, p2, p3)
+ >>> t.incircle
+ Circle(Point2D(2 - sqrt(2), 2 - sqrt(2)), 2 - sqrt(2))
+
+ """
+ return Circle(self.incenter, self.inradius)
+
+ @property
+ def exradii(self):
+ """The radius of excircles of a triangle.
+
+ An excircle of the triangle is a circle lying outside the triangle,
+ tangent to one of its sides and tangent to the extensions of the
+ other two.
+
+ Returns
+ =======
+
+ exradii : dict
+
+ See Also
+ ========
+
+ sympy.geometry.polygon.Triangle.inradius
+
+ Examples
+ ========
+
+ The exradius touches the side of the triangle to which it is keyed, e.g.
+ the exradius touching side 2 is:
+
+ >>> from sympy import Point, Triangle
+ >>> p1, p2, p3 = Point(0, 0), Point(6, 0), Point(0, 2)
+ >>> t = Triangle(p1, p2, p3)
+ >>> t.exradii[t.sides[2]]
+ -2 + sqrt(10)
+
+ References
+ ==========
+
+ .. [1] https://mathworld.wolfram.com/Exradius.html
+ .. [2] https://mathworld.wolfram.com/Excircles.html
+
+ """
+
+ side = self.sides
+ a = side[0].length
+ b = side[1].length
+ c = side[2].length
+ s = (a+b+c)/2
+ area = self.area
+ exradii = {self.sides[0]: simplify(area/(s-a)),
+ self.sides[1]: simplify(area/(s-b)),
+ self.sides[2]: simplify(area/(s-c))}
+
+ return exradii
+
+ @property
+ def excenters(self):
+ """Excenters of the triangle.
+
+ An excenter is the center of a circle that is tangent to a side of the
+ triangle and the extensions of the other two sides.
+
+ Returns
+ =======
+
+ excenters : dict
+
+
+ Examples
+ ========
+
+ The excenters are keyed to the side of the triangle to which their corresponding
+ excircle is tangent: The center is keyed, e.g. the excenter of a circle touching
+ side 0 is:
+
+ >>> from sympy import Point, Triangle
+ >>> p1, p2, p3 = Point(0, 0), Point(6, 0), Point(0, 2)
+ >>> t = Triangle(p1, p2, p3)
+ >>> t.excenters[t.sides[0]]
+ Point2D(12*sqrt(10), 2/3 + sqrt(10)/3)
+
+ See Also
+ ========
+
+ sympy.geometry.polygon.Triangle.exradii
+
+ References
+ ==========
+
+ .. [1] https://mathworld.wolfram.com/Excircles.html
+
+ """
+
+ s = self.sides
+ v = self.vertices
+ a = s[0].length
+ b = s[1].length
+ c = s[2].length
+ x = [v[0].x, v[1].x, v[2].x]
+ y = [v[0].y, v[1].y, v[2].y]
+
+ exc_coords = {
+ "x1": simplify(-a*x[0]+b*x[1]+c*x[2]/(-a+b+c)),
+ "x2": simplify(a*x[0]-b*x[1]+c*x[2]/(a-b+c)),
+ "x3": simplify(a*x[0]+b*x[1]-c*x[2]/(a+b-c)),
+ "y1": simplify(-a*y[0]+b*y[1]+c*y[2]/(-a+b+c)),
+ "y2": simplify(a*y[0]-b*y[1]+c*y[2]/(a-b+c)),
+ "y3": simplify(a*y[0]+b*y[1]-c*y[2]/(a+b-c))
+ }
+
+ excenters = {
+ s[0]: Point(exc_coords["x1"], exc_coords["y1"]),
+ s[1]: Point(exc_coords["x2"], exc_coords["y2"]),
+ s[2]: Point(exc_coords["x3"], exc_coords["y3"])
+ }
+
+ return excenters
+
+ @property
+ def medians(self):
+ """The medians of the triangle.
+
+ A median of a triangle is a straight line through a vertex and the
+ midpoint of the opposite side, and divides the triangle into two
+ equal areas.
+
+ Returns
+ =======
+
+ medians : dict
+ Each key is a vertex (Point) and each value is the median (Segment)
+ at that point.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point.midpoint, sympy.geometry.line.Segment.midpoint
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Triangle
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+ >>> t = Triangle(p1, p2, p3)
+ >>> t.medians[p1]
+ Segment2D(Point2D(0, 0), Point2D(1/2, 1/2))
+
+ """
+ s = self.sides
+ v = self.vertices
+ return {v[0]: Segment(v[0], s[1].midpoint),
+ v[1]: Segment(v[1], s[2].midpoint),
+ v[2]: Segment(v[2], s[0].midpoint)}
+
+ @property
+ def medial(self):
+ """The medial triangle of the triangle.
+
+ The triangle which is formed from the midpoints of the three sides.
+
+ Returns
+ =======
+
+ medial : Triangle
+
+ See Also
+ ========
+
+ sympy.geometry.line.Segment.midpoint
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Triangle
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+ >>> t = Triangle(p1, p2, p3)
+ >>> t.medial
+ Triangle(Point2D(1/2, 0), Point2D(1/2, 1/2), Point2D(0, 1/2))
+
+ """
+ s = self.sides
+ return Triangle(s[0].midpoint, s[1].midpoint, s[2].midpoint)
+
+ @property
+ def nine_point_circle(self):
+ """The nine-point circle of the triangle.
+
+ Nine-point circle is the circumcircle of the medial triangle, which
+ passes through the feet of altitudes and the middle points of segments
+ connecting the vertices and the orthocenter.
+
+ Returns
+ =======
+
+ nine_point_circle : Circle
+
+ See also
+ ========
+
+ sympy.geometry.line.Segment.midpoint
+ sympy.geometry.polygon.Triangle.medial
+ sympy.geometry.polygon.Triangle.orthocenter
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Triangle
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+ >>> t = Triangle(p1, p2, p3)
+ >>> t.nine_point_circle
+ Circle(Point2D(1/4, 1/4), sqrt(2)/4)
+
+ """
+ return Circle(*self.medial.vertices)
+
+ @property
+ def eulerline(self):
+ """The Euler line of the triangle.
+
+ The line which passes through circumcenter, centroid and orthocenter.
+
+ Returns
+ =======
+
+ eulerline : Line (or Point for equilateral triangles in which case all
+ centers coincide)
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Triangle
+ >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+ >>> t = Triangle(p1, p2, p3)
+ >>> t.eulerline
+ Line2D(Point2D(0, 0), Point2D(1/2, 1/2))
+
+ """
+ if self.is_equilateral():
+ return self.orthocenter
+ return Line(self.orthocenter, self.circumcenter)
+
+def rad(d):
+ """Return the radian value for the given degrees (pi = 180 degrees)."""
+ return d*pi/180
+
+
+def deg(r):
+ """Return the degree value for the given radians (pi = 180 degrees)."""
+ return r/pi*180
+
+
+def _slope(d):
+ rv = tan(rad(d))
+ return rv
+
+
+def _asa(d1, l, d2):
+ """Return triangle having side with length l on the x-axis."""
+ xy = Line((0, 0), slope=_slope(d1)).intersection(
+ Line((l, 0), slope=_slope(180 - d2)))[0]
+ return Triangle((0, 0), (l, 0), xy)
+
+
+def _sss(l1, l2, l3):
+ """Return triangle having side of length l1 on the x-axis."""
+ c1 = Circle((0, 0), l3)
+ c2 = Circle((l1, 0), l2)
+ inter = [a for a in c1.intersection(c2) if a.y.is_nonnegative]
+ if not inter:
+ return None
+ pt = inter[0]
+ return Triangle((0, 0), (l1, 0), pt)
+
+
+def _sas(l1, d, l2):
+ """Return triangle having side with length l2 on the x-axis."""
+ p1 = Point(0, 0)
+ p2 = Point(l2, 0)
+ p3 = Point(cos(rad(d))*l1, sin(rad(d))*l1)
+ return Triangle(p1, p2, p3)
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/tests/__init__.py b/janus/lib/python3.10/site-packages/sympy/geometry/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_geometrysets.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_geometrysets.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..821ee244b28064a160efd11fa861c4d4f97e7a0d
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_geometrysets.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_plane.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_plane.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6261b0b6e14227bd399ac4df01569920f71cf672
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_plane.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_point.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_point.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e9cd019376484f30bdf602d6f490d880f4776a3b
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_point.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_util.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_util.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fcc089f8f3ca8409dd6ed2e672e74bc7039af0d5
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/geometry/tests/__pycache__/test_util.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/tests/test_curve.py b/janus/lib/python3.10/site-packages/sympy/geometry/tests/test_curve.py
new file mode 100644
index 0000000000000000000000000000000000000000..50aa80273a1d8eb9e414a8d591571f3127352dad
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/geometry/tests/test_curve.py
@@ -0,0 +1,120 @@
+from sympy.core.containers import Tuple
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.hyperbolic import asinh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.geometry import Curve, Line, Point, Ellipse, Ray, Segment, Circle, Polygon, RegularPolygon
+from sympy.testing.pytest import raises, slow
+
+
+def test_curve():
+ x = Symbol('x', real=True)
+ s = Symbol('s')
+ z = Symbol('z')
+
+ # this curve is independent of the indicated parameter
+ c = Curve([2*s, s**2], (z, 0, 2))
+
+ assert c.parameter == z
+ assert c.functions == (2*s, s**2)
+ assert c.arbitrary_point() == Point(2*s, s**2)
+ assert c.arbitrary_point(z) == Point(2*s, s**2)
+
+ # this is how it is normally used
+ c = Curve([2*s, s**2], (s, 0, 2))
+
+ assert c.parameter == s
+ assert c.functions == (2*s, s**2)
+ t = Symbol('t')
+ # the t returned as assumptions
+ assert c.arbitrary_point() != Point(2*t, t**2)
+ t = Symbol('t', real=True)
+ # now t has the same assumptions so the test passes
+ assert c.arbitrary_point() == Point(2*t, t**2)
+ assert c.arbitrary_point(z) == Point(2*z, z**2)
+ assert c.arbitrary_point(c.parameter) == Point(2*s, s**2)
+ assert c.arbitrary_point(None) == Point(2*s, s**2)
+ assert c.plot_interval() == [t, 0, 2]
+ assert c.plot_interval(z) == [z, 0, 2]
+
+ assert Curve([x, x], (x, 0, 1)).rotate(pi/2) == Curve([-x, x], (x, 0, 1))
+ assert Curve([x, x], (x, 0, 1)).rotate(pi/2, (1, 2)).scale(2, 3).translate(
+ 1, 3).arbitrary_point(s) == \
+ Line((0, 0), (1, 1)).rotate(pi/2, (1, 2)).scale(2, 3).translate(
+ 1, 3).arbitrary_point(s) == \
+ Point(-2*s + 7, 3*s + 6)
+
+ raises(ValueError, lambda: Curve((s), (s, 1, 2)))
+ raises(ValueError, lambda: Curve((x, x * 2), (1, x)))
+
+ raises(ValueError, lambda: Curve((s, s + t), (s, 1, 2)).arbitrary_point())
+ raises(ValueError, lambda: Curve((s, s + t), (t, 1, 2)).arbitrary_point(s))
+
+
+@slow
+def test_free_symbols():
+ a, b, c, d, e, f, s = symbols('a:f,s')
+ assert Point(a, b).free_symbols == {a, b}
+ assert Line((a, b), (c, d)).free_symbols == {a, b, c, d}
+ assert Ray((a, b), (c, d)).free_symbols == {a, b, c, d}
+ assert Ray((a, b), angle=c).free_symbols == {a, b, c}
+ assert Segment((a, b), (c, d)).free_symbols == {a, b, c, d}
+ assert Line((a, b), slope=c).free_symbols == {a, b, c}
+ assert Curve((a*s, b*s), (s, c, d)).free_symbols == {a, b, c, d}
+ assert Ellipse((a, b), c, d).free_symbols == {a, b, c, d}
+ assert Ellipse((a, b), c, eccentricity=d).free_symbols == \
+ {a, b, c, d}
+ assert Ellipse((a, b), vradius=c, eccentricity=d).free_symbols == \
+ {a, b, c, d}
+ assert Circle((a, b), c).free_symbols == {a, b, c}
+ assert Circle((a, b), (c, d), (e, f)).free_symbols == \
+ {e, d, c, b, f, a}
+ assert Polygon((a, b), (c, d), (e, f)).free_symbols == \
+ {e, b, d, f, a, c}
+ assert RegularPolygon((a, b), c, d, e).free_symbols == {e, a, b, c, d}
+
+
+def test_transform():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+ c = Curve((x, x**2), (x, 0, 1))
+ cout = Curve((2*x - 4, 3*x**2 - 10), (x, 0, 1))
+ pts = [Point(0, 0), Point(S.Half, Rational(1, 4)), Point(1, 1)]
+ pts_out = [Point(-4, -10), Point(-3, Rational(-37, 4)), Point(-2, -7)]
+
+ assert c.scale(2, 3, (4, 5)) == cout
+ assert [c.subs(x, xi/2) for xi in Tuple(0, 1, 2)] == pts
+ assert [cout.subs(x, xi/2) for xi in Tuple(0, 1, 2)] == pts_out
+ assert Curve((x + y, 3*x), (x, 0, 1)).subs(y, S.Half) == \
+ Curve((x + S.Half, 3*x), (x, 0, 1))
+ assert Curve((x, 3*x), (x, 0, 1)).translate(4, 5) == \
+ Curve((x + 4, 3*x + 5), (x, 0, 1))
+
+
+def test_length():
+ t = Symbol('t', real=True)
+
+ c1 = Curve((t, 0), (t, 0, 1))
+ assert c1.length == 1
+
+ c2 = Curve((t, t), (t, 0, 1))
+ assert c2.length == sqrt(2)
+
+ c3 = Curve((t ** 2, t), (t, 2, 5))
+ assert c3.length == -sqrt(17) - asinh(4) / 4 + asinh(10) / 4 + 5 * sqrt(101) / 2
+
+
+def test_parameter_value():
+ t = Symbol('t')
+ C = Curve([2*t, t**2], (t, 0, 2))
+ assert C.parameter_value((2, 1), t) == {t: 1}
+ raises(ValueError, lambda: C.parameter_value((2, 0), t))
+
+
+def test_issue_17997():
+ t, s = symbols('t s')
+ c = Curve((t, t**2), (t, 0, 10))
+ p = Curve([2*s, s**2], (s, 0, 2))
+ assert c(2) == Point(2, 4)
+ assert p(1) == Point(2, 1)
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/tests/test_entity.py b/janus/lib/python3.10/site-packages/sympy/geometry/tests/test_entity.py
new file mode 100644
index 0000000000000000000000000000000000000000..cecfdb785506d1b2f4ef496703c430794f09e589
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/geometry/tests/test_entity.py
@@ -0,0 +1,120 @@
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.geometry import (Circle, Ellipse, Point, Line, Parabola,
+ Polygon, Ray, RegularPolygon, Segment, Triangle, Plane, Curve)
+from sympy.geometry.entity import scale, GeometryEntity
+from sympy.testing.pytest import raises
+
+
+def test_entity():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+
+ assert GeometryEntity(x, y) in GeometryEntity(x, y)
+ raises(NotImplementedError, lambda: Point(0, 0) in GeometryEntity(x, y))
+
+ assert GeometryEntity(x, y) == GeometryEntity(x, y)
+ assert GeometryEntity(x, y).equals(GeometryEntity(x, y))
+
+ c = Circle((0, 0), 5)
+ assert GeometryEntity.encloses(c, Point(0, 0))
+ assert GeometryEntity.encloses(c, Segment((0, 0), (1, 1)))
+ assert GeometryEntity.encloses(c, Line((0, 0), (1, 1))) is False
+ assert GeometryEntity.encloses(c, Circle((0, 0), 4))
+ assert GeometryEntity.encloses(c, Polygon(Point(0, 0), Point(1, 0), Point(0, 1)))
+ assert GeometryEntity.encloses(c, RegularPolygon(Point(8, 8), 1, 3)) is False
+
+
+def test_svg():
+ a = Symbol('a')
+ b = Symbol('b')
+ d = Symbol('d')
+
+ entity = Circle(Point(a, b), d)
+ assert entity._repr_svg_() is None
+
+ entity = Circle(Point(0, 0), S.Infinity)
+ assert entity._repr_svg_() is None
+
+
+def test_subs():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+ p = Point(x, 2)
+ q = Point(1, 1)
+ r = Point(3, 4)
+ for o in [p,
+ Segment(p, q),
+ Ray(p, q),
+ Line(p, q),
+ Triangle(p, q, r),
+ RegularPolygon(p, 3, 6),
+ Polygon(p, q, r, Point(5, 4)),
+ Circle(p, 3),
+ Ellipse(p, 3, 4)]:
+ assert 'y' in str(o.subs(x, y))
+ assert p.subs({x: 1}) == Point(1, 2)
+ assert Point(1, 2).subs(Point(1, 2), Point(3, 4)) == Point(3, 4)
+ assert Point(1, 2).subs((1, 2), Point(3, 4)) == Point(3, 4)
+ assert Point(1, 2).subs(Point(1, 2), Point(3, 4)) == Point(3, 4)
+ assert Point(1, 2).subs({(1, 2)}) == Point(2, 2)
+ raises(ValueError, lambda: Point(1, 2).subs(1))
+ raises(ValueError, lambda: Point(1, 1).subs((Point(1, 1), Point(1,
+ 2)), 1, 2))
+
+
+def test_transform():
+ assert scale(1, 2, (3, 4)).tolist() == \
+ [[1, 0, 0], [0, 2, 0], [0, -4, 1]]
+
+
+def test_reflect_entity_overrides():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+ b = Symbol('b')
+ m = Symbol('m')
+ l = Line((0, b), slope=m)
+ p = Point(x, y)
+ r = p.reflect(l)
+ c = Circle((x, y), 3)
+ cr = c.reflect(l)
+ assert cr == Circle(r, -3)
+ assert c.area == -cr.area
+
+ pent = RegularPolygon((1, 2), 1, 5)
+ slope = S.ComplexInfinity
+ while slope is S.ComplexInfinity:
+ slope = Rational(*(x._random()/2).as_real_imag())
+ l = Line(pent.vertices[1], slope=slope)
+ rpent = pent.reflect(l)
+ assert rpent.center == pent.center.reflect(l)
+ rvert = [i.reflect(l) for i in pent.vertices]
+ for v in rpent.vertices:
+ for i in range(len(rvert)):
+ ri = rvert[i]
+ if ri.equals(v):
+ rvert.remove(ri)
+ break
+ assert not rvert
+ assert pent.area.equals(-rpent.area)
+
+
+def test_geometry_EvalfMixin():
+ x = pi
+ t = Symbol('t')
+ for g in [
+ Point(x, x),
+ Plane(Point(0, x, 0), (0, 0, x)),
+ Curve((x*t, x), (t, 0, x)),
+ Ellipse((x, x), x, -x),
+ Circle((x, x), x),
+ Line((0, x), (x, 0)),
+ Segment((0, x), (x, 0)),
+ Ray((0, x), (x, 0)),
+ Parabola((0, x), Line((-x, 0), (x, 0))),
+ Polygon((0, 0), (0, x), (x, 0), (x, x)),
+ RegularPolygon((0, x), x, 4, x),
+ Triangle((0, 0), (x, 0), (x, x)),
+ ]:
+ assert str(g).replace('pi', '3.1') == str(g.n(2))
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/tests/test_geometrysets.py b/janus/lib/python3.10/site-packages/sympy/geometry/tests/test_geometrysets.py
new file mode 100644
index 0000000000000000000000000000000000000000..c52898b3c9ba4e9db80c244db3aebf88db2cc8b4
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/geometry/tests/test_geometrysets.py
@@ -0,0 +1,38 @@
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.geometry import Circle, Line, Point, Polygon, Segment
+from sympy.sets import FiniteSet, Union, Intersection, EmptySet
+
+
+def test_booleans():
+ """ test basic unions and intersections """
+ half = S.Half
+
+ p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+ p5, p6, p7 = map(Point, [(3, 2), (1, -1), (0, 2)])
+ l1 = Line(Point(0,0), Point(1,1))
+ l2 = Line(Point(half, half), Point(5,5))
+ l3 = Line(p2, p3)
+ l4 = Line(p3, p4)
+ poly1 = Polygon(p1, p2, p3, p4)
+ poly2 = Polygon(p5, p6, p7)
+ poly3 = Polygon(p1, p2, p5)
+ assert Union(l1, l2).equals(l1)
+ assert Intersection(l1, l2).equals(l1)
+ assert Intersection(l1, l4) == FiniteSet(Point(1,1))
+ assert Intersection(Union(l1, l4), l3) == FiniteSet(Point(Rational(-1, 3), Rational(-1, 3)), Point(5, 1))
+ assert Intersection(l1, FiniteSet(Point(7,-7))) == EmptySet
+ assert Intersection(Circle(Point(0,0), 3), Line(p1,p2)) == FiniteSet(Point(-3,0), Point(3,0))
+ assert Intersection(l1, FiniteSet(p1)) == FiniteSet(p1)
+ assert Union(l1, FiniteSet(p1)) == l1
+
+ fs = FiniteSet(Point(Rational(1, 3), 1), Point(Rational(2, 3), 0), Point(Rational(9, 5), Rational(1, 5)), Point(Rational(7, 3), 1))
+ # test the intersection of polygons
+ assert Intersection(poly1, poly2) == fs
+ # make sure if we union polygons with subsets, the subsets go away
+ assert Union(poly1, poly2, fs) == Union(poly1, poly2)
+ # make sure that if we union with a FiniteSet that isn't a subset,
+ # that the points in the intersection stop being listed
+ assert Union(poly1, FiniteSet(Point(0,0), Point(3,5))) == Union(poly1, FiniteSet(Point(3,5)))
+ # intersect two polygons that share an edge
+ assert Intersection(poly1, poly3) == Union(FiniteSet(Point(Rational(3, 2), 1), Point(2, 1)), Segment(Point(0, 0), Point(1, 0)))
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/tests/test_polygon.py b/janus/lib/python3.10/site-packages/sympy/geometry/tests/test_polygon.py
new file mode 100644
index 0000000000000000000000000000000000000000..976d71078a4ef8d535a9508a64f414c80da16847
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/geometry/tests/test_polygon.py
@@ -0,0 +1,676 @@
+from sympy.core.numbers import (Float, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, cos, sin)
+from sympy.functions.elementary.trigonometric import tan
+from sympy.geometry import (Circle, Ellipse, GeometryError, Point, Point2D,
+ Polygon, Ray, RegularPolygon, Segment, Triangle,
+ are_similar, convex_hull, intersection, Line, Ray2D)
+from sympy.testing.pytest import raises, slow, warns
+from sympy.core.random import verify_numerically
+from sympy.geometry.polygon import rad, deg
+from sympy.integrals.integrals import integrate
+from sympy.utilities.iterables import rotate_left
+
+
+def feq(a, b):
+ """Test if two floating point values are 'equal'."""
+ t_float = Float("1.0E-10")
+ return -t_float < a - b < t_float
+
+@slow
+def test_polygon():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+ q = Symbol('q', real=True)
+ u = Symbol('u', real=True)
+ v = Symbol('v', real=True)
+ w = Symbol('w', real=True)
+ x1 = Symbol('x1', real=True)
+ half = S.Half
+ a, b, c = Point(0, 0), Point(2, 0), Point(3, 3)
+ t = Triangle(a, b, c)
+ assert Polygon(Point(0, 0)) == Point(0, 0)
+ assert Polygon(a, Point(1, 0), b, c) == t
+ assert Polygon(Point(1, 0), b, c, a) == t
+ assert Polygon(b, c, a, Point(1, 0)) == t
+ # 2 "remove folded" tests
+ assert Polygon(a, Point(3, 0), b, c) == t
+ assert Polygon(a, b, Point(3, -1), b, c) == t
+ # remove multiple collinear points
+ assert Polygon(Point(-4, 15), Point(-11, 15), Point(-15, 15),
+ Point(-15, 33/5), Point(-15, -87/10), Point(-15, -15),
+ Point(-42/5, -15), Point(-2, -15), Point(7, -15), Point(15, -15),
+ Point(15, -3), Point(15, 10), Point(15, 15)) == \
+ Polygon(Point(-15, -15), Point(15, -15), Point(15, 15), Point(-15, 15))
+
+ p1 = Polygon(
+ Point(0, 0), Point(3, -1),
+ Point(6, 0), Point(4, 5),
+ Point(2, 3), Point(0, 3))
+ p2 = Polygon(
+ Point(6, 0), Point(3, -1),
+ Point(0, 0), Point(0, 3),
+ Point(2, 3), Point(4, 5))
+ p3 = Polygon(
+ Point(0, 0), Point(3, 0),
+ Point(5, 2), Point(4, 4))
+ p4 = Polygon(
+ Point(0, 0), Point(4, 4),
+ Point(5, 2), Point(3, 0))
+ p5 = Polygon(
+ Point(0, 0), Point(4, 4),
+ Point(0, 4))
+ p6 = Polygon(
+ Point(-11, 1), Point(-9, 6.6),
+ Point(-4, -3), Point(-8.4, -8.7))
+ p7 = Polygon(
+ Point(x, y), Point(q, u),
+ Point(v, w))
+ p8 = Polygon(
+ Point(x, y), Point(v, w),
+ Point(q, u))
+ p9 = Polygon(
+ Point(0, 0), Point(4, 4),
+ Point(3, 0), Point(5, 2))
+ p10 = Polygon(
+ Point(0, 2), Point(2, 2),
+ Point(0, 0), Point(2, 0))
+ p11 = Polygon(Point(0, 0), 1, n=3)
+ p12 = Polygon(Point(0, 0), 1, 0, n=3)
+ p13 = Polygon(
+ Point(0, 0),Point(8, 8),
+ Point(23, 20),Point(0, 20))
+ p14 = Polygon(*rotate_left(p13.args, 1))
+
+
+ r = Ray(Point(-9, 6.6), Point(-9, 5.5))
+ #
+ # General polygon
+ #
+ assert p1 == p2
+ assert len(p1.args) == 6
+ assert len(p1.sides) == 6
+ assert p1.perimeter == 5 + 2*sqrt(10) + sqrt(29) + sqrt(8)
+ assert p1.area == 22
+ assert not p1.is_convex()
+ assert Polygon((-1, 1), (2, -1), (2, 1), (-1, -1), (3, 0)
+ ).is_convex() is False
+ # ensure convex for both CW and CCW point specification
+ assert p3.is_convex()
+ assert p4.is_convex()
+ dict5 = p5.angles
+ assert dict5[Point(0, 0)] == pi / 4
+ assert dict5[Point(0, 4)] == pi / 2
+ assert p5.encloses_point(Point(x, y)) is None
+ assert p5.encloses_point(Point(1, 3))
+ assert p5.encloses_point(Point(0, 0)) is False
+ assert p5.encloses_point(Point(4, 0)) is False
+ assert p1.encloses(Circle(Point(2.5, 2.5), 5)) is False
+ assert p1.encloses(Ellipse(Point(2.5, 2), 5, 6)) is False
+ assert p5.plot_interval('x') == [x, 0, 1]
+ assert p5.distance(
+ Polygon(Point(10, 10), Point(14, 14), Point(10, 14))) == 6 * sqrt(2)
+ assert p5.distance(
+ Polygon(Point(1, 8), Point(5, 8), Point(8, 12), Point(1, 12))) == 4
+ with warns(UserWarning, \
+ match="Polygons may intersect producing erroneous output"):
+ Polygon(Point(0, 0), Point(1, 0), Point(1, 1)).distance(
+ Polygon(Point(0, 0), Point(0, 1), Point(1, 1)))
+ assert hash(p5) == hash(Polygon(Point(0, 0), Point(4, 4), Point(0, 4)))
+ assert hash(p1) == hash(p2)
+ assert hash(p7) == hash(p8)
+ assert hash(p3) != hash(p9)
+ assert p5 == Polygon(Point(4, 4), Point(0, 4), Point(0, 0))
+ assert Polygon(Point(4, 4), Point(0, 4), Point(0, 0)) in p5
+ assert p5 != Point(0, 4)
+ assert Point(0, 1) in p5
+ assert p5.arbitrary_point('t').subs(Symbol('t', real=True), 0) == \
+ Point(0, 0)
+ raises(ValueError, lambda: Polygon(
+ Point(x, 0), Point(0, y), Point(x, y)).arbitrary_point('x'))
+ assert p6.intersection(r) == [Point(-9, Rational(-84, 13)), Point(-9, Rational(33, 5))]
+ assert p10.area == 0
+ assert p11 == RegularPolygon(Point(0, 0), 1, 3, 0)
+ assert p11 == p12
+ assert p11.vertices[0] == Point(1, 0)
+ assert p11.args[0] == Point(0, 0)
+ p11.spin(pi/2)
+ assert p11.vertices[0] == Point(0, 1)
+ #
+ # Regular polygon
+ #
+ p1 = RegularPolygon(Point(0, 0), 10, 5)
+ p2 = RegularPolygon(Point(0, 0), 5, 5)
+ raises(GeometryError, lambda: RegularPolygon(Point(0, 0), Point(0,
+ 1), Point(1, 1)))
+ raises(GeometryError, lambda: RegularPolygon(Point(0, 0), 1, 2))
+ raises(ValueError, lambda: RegularPolygon(Point(0, 0), 1, 2.5))
+
+ assert p1 != p2
+ assert p1.interior_angle == pi*Rational(3, 5)
+ assert p1.exterior_angle == pi*Rational(2, 5)
+ assert p2.apothem == 5*cos(pi/5)
+ assert p2.circumcenter == p1.circumcenter == Point(0, 0)
+ assert p1.circumradius == p1.radius == 10
+ assert p2.circumcircle == Circle(Point(0, 0), 5)
+ assert p2.incircle == Circle(Point(0, 0), p2.apothem)
+ assert p2.inradius == p2.apothem == (5 * (1 + sqrt(5)) / 4)
+ p2.spin(pi / 10)
+ dict1 = p2.angles
+ assert dict1[Point(0, 5)] == 3 * pi / 5
+ assert p1.is_convex()
+ assert p1.rotation == 0
+ assert p1.encloses_point(Point(0, 0))
+ assert p1.encloses_point(Point(11, 0)) is False
+ assert p2.encloses_point(Point(0, 4.9))
+ p1.spin(pi/3)
+ assert p1.rotation == pi/3
+ assert p1.vertices[0] == Point(5, 5*sqrt(3))
+ for var in p1.args:
+ if isinstance(var, Point):
+ assert var == Point(0, 0)
+ else:
+ assert var in (5, 10, pi / 3)
+ assert p1 != Point(0, 0)
+ assert p1 != p5
+
+ # while spin works in place (notice that rotation is 2pi/3 below)
+ # rotate returns a new object
+ p1_old = p1
+ assert p1.rotate(pi/3) == RegularPolygon(Point(0, 0), 10, 5, pi*Rational(2, 3))
+ assert p1 == p1_old
+
+ assert p1.area == (-250*sqrt(5) + 1250)/(4*tan(pi/5))
+ assert p1.length == 20*sqrt(-sqrt(5)/8 + Rational(5, 8))
+ assert p1.scale(2, 2) == \
+ RegularPolygon(p1.center, p1.radius*2, p1._n, p1.rotation)
+ assert RegularPolygon((0, 0), 1, 4).scale(2, 3) == \
+ Polygon(Point(2, 0), Point(0, 3), Point(-2, 0), Point(0, -3))
+
+ assert repr(p1) == str(p1)
+
+ #
+ # Angles
+ #
+ angles = p4.angles
+ assert feq(angles[Point(0, 0)].evalf(), Float("0.7853981633974483"))
+ assert feq(angles[Point(4, 4)].evalf(), Float("1.2490457723982544"))
+ assert feq(angles[Point(5, 2)].evalf(), Float("1.8925468811915388"))
+ assert feq(angles[Point(3, 0)].evalf(), Float("2.3561944901923449"))
+
+ angles = p3.angles
+ assert feq(angles[Point(0, 0)].evalf(), Float("0.7853981633974483"))
+ assert feq(angles[Point(4, 4)].evalf(), Float("1.2490457723982544"))
+ assert feq(angles[Point(5, 2)].evalf(), Float("1.8925468811915388"))
+ assert feq(angles[Point(3, 0)].evalf(), Float("2.3561944901923449"))
+
+ # https://github.com/sympy/sympy/issues/24885
+ interior_angles_sum = sum(p13.angles.values())
+ assert feq(interior_angles_sum, (len(p13.angles) - 2)*pi )
+ interior_angles_sum = sum(p14.angles.values())
+ assert feq(interior_angles_sum, (len(p14.angles) - 2)*pi )
+
+ #
+ # Triangle
+ #
+ p1 = Point(0, 0)
+ p2 = Point(5, 0)
+ p3 = Point(0, 5)
+ t1 = Triangle(p1, p2, p3)
+ t2 = Triangle(p1, p2, Point(Rational(5, 2), sqrt(Rational(75, 4))))
+ t3 = Triangle(p1, Point(x1, 0), Point(0, x1))
+ s1 = t1.sides
+ assert Triangle(p1, p2, p1) == Polygon(p1, p2, p1) == Segment(p1, p2)
+ raises(GeometryError, lambda: Triangle(Point(0, 0)))
+
+ # Basic stuff
+ assert Triangle(p1, p1, p1) == p1
+ assert Triangle(p2, p2*2, p2*3) == Segment(p2, p2*3)
+ assert t1.area == Rational(25, 2)
+ assert t1.is_right()
+ assert t2.is_right() is False
+ assert t3.is_right()
+ assert p1 in t1
+ assert t1.sides[0] in t1
+ assert Segment((0, 0), (1, 0)) in t1
+ assert Point(5, 5) not in t2
+ assert t1.is_convex()
+ assert feq(t1.angles[p1].evalf(), pi.evalf()/2)
+
+ assert t1.is_equilateral() is False
+ assert t2.is_equilateral()
+ assert t3.is_equilateral() is False
+ assert are_similar(t1, t2) is False
+ assert are_similar(t1, t3)
+ assert are_similar(t2, t3) is False
+ assert t1.is_similar(Point(0, 0)) is False
+ assert t1.is_similar(t2) is False
+
+ # Bisectors
+ bisectors = t1.bisectors()
+ assert bisectors[p1] == Segment(
+ p1, Point(Rational(5, 2), Rational(5, 2)))
+ assert t2.bisectors()[p2] == Segment(
+ Point(5, 0), Point(Rational(5, 4), 5*sqrt(3)/4))
+ p4 = Point(0, x1)
+ assert t3.bisectors()[p4] == Segment(p4, Point(x1*(sqrt(2) - 1), 0))
+ ic = (250 - 125*sqrt(2))/50
+ assert t1.incenter == Point(ic, ic)
+
+ # Inradius
+ assert t1.inradius == t1.incircle.radius == 5 - 5*sqrt(2)/2
+ assert t2.inradius == t2.incircle.radius == 5*sqrt(3)/6
+ assert t3.inradius == t3.incircle.radius == x1**2/((2 + sqrt(2))*Abs(x1))
+
+ # Exradius
+ assert t1.exradii[t1.sides[2]] == 5*sqrt(2)/2
+
+ # Excenters
+ assert t1.excenters[t1.sides[2]] == Point2D(25*sqrt(2), -5*sqrt(2)/2)
+
+ # Circumcircle
+ assert t1.circumcircle.center == Point(2.5, 2.5)
+
+ # Medians + Centroid
+ m = t1.medians
+ assert t1.centroid == Point(Rational(5, 3), Rational(5, 3))
+ assert m[p1] == Segment(p1, Point(Rational(5, 2), Rational(5, 2)))
+ assert t3.medians[p1] == Segment(p1, Point(x1/2, x1/2))
+ assert intersection(m[p1], m[p2], m[p3]) == [t1.centroid]
+ assert t1.medial == Triangle(Point(2.5, 0), Point(0, 2.5), Point(2.5, 2.5))
+
+ # Nine-point circle
+ assert t1.nine_point_circle == Circle(Point(2.5, 0),
+ Point(0, 2.5), Point(2.5, 2.5))
+ assert t1.nine_point_circle == Circle(Point(0, 0),
+ Point(0, 2.5), Point(2.5, 2.5))
+
+ # Perpendicular
+ altitudes = t1.altitudes
+ assert altitudes[p1] == Segment(p1, Point(Rational(5, 2), Rational(5, 2)))
+ assert altitudes[p2].equals(s1[0])
+ assert altitudes[p3] == s1[2]
+ assert t1.orthocenter == p1
+ t = S('''Triangle(
+ Point(100080156402737/5000000000000, 79782624633431/500000000000),
+ Point(39223884078253/2000000000000, 156345163124289/1000000000000),
+ Point(31241359188437/1250000000000, 338338270939941/1000000000000000))''')
+ assert t.orthocenter == S('''Point(-780660869050599840216997'''
+ '''79471538701955848721853/80368430960602242240789074233100000000000000,'''
+ '''20151573611150265741278060334545897615974257/16073686192120448448157'''
+ '''8148466200000000000)''')
+
+ # Ensure
+ assert len(intersection(*bisectors.values())) == 1
+ assert len(intersection(*altitudes.values())) == 1
+ assert len(intersection(*m.values())) == 1
+
+ # Distance
+ p1 = Polygon(
+ Point(0, 0), Point(1, 0),
+ Point(1, 1), Point(0, 1))
+ p2 = Polygon(
+ Point(0, Rational(5)/4), Point(1, Rational(5)/4),
+ Point(1, Rational(9)/4), Point(0, Rational(9)/4))
+ p3 = Polygon(
+ Point(1, 2), Point(2, 2),
+ Point(2, 1))
+ p4 = Polygon(
+ Point(1, 1), Point(Rational(6)/5, 1),
+ Point(1, Rational(6)/5))
+ pt1 = Point(half, half)
+ pt2 = Point(1, 1)
+
+ '''Polygon to Point'''
+ assert p1.distance(pt1) == half
+ assert p1.distance(pt2) == 0
+ assert p2.distance(pt1) == Rational(3)/4
+ assert p3.distance(pt2) == sqrt(2)/2
+
+ '''Polygon to Polygon'''
+ # p1.distance(p2) emits a warning
+ with warns(UserWarning, \
+ match="Polygons may intersect producing erroneous output"):
+ assert p1.distance(p2) == half/2
+
+ assert p1.distance(p3) == sqrt(2)/2
+
+ # p3.distance(p4) emits a warning
+ with warns(UserWarning, \
+ match="Polygons may intersect producing erroneous output"):
+ assert p3.distance(p4) == (sqrt(2)/2 - sqrt(Rational(2)/25)/2)
+
+
+def test_convex_hull():
+ p = [Point(-5, -1), Point(-2, 1), Point(-2, -1), Point(-1, -3), \
+ Point(0, 0), Point(1, 1), Point(2, 2), Point(2, -1), Point(3, 1), \
+ Point(4, -1), Point(6, 2)]
+ ch = Polygon(p[0], p[3], p[9], p[10], p[6], p[1])
+ #test handling of duplicate points
+ p.append(p[3])
+
+ #more than 3 collinear points
+ another_p = [Point(-45, -85), Point(-45, 85), Point(-45, 26), \
+ Point(-45, -24)]
+ ch2 = Segment(another_p[0], another_p[1])
+
+ assert convex_hull(*another_p) == ch2
+ assert convex_hull(*p) == ch
+ assert convex_hull(p[0]) == p[0]
+ assert convex_hull(p[0], p[1]) == Segment(p[0], p[1])
+
+ # no unique points
+ assert convex_hull(*[p[-1]]*3) == p[-1]
+
+ # collection of items
+ assert convex_hull(*[Point(0, 0), \
+ Segment(Point(1, 0), Point(1, 1)), \
+ RegularPolygon(Point(2, 0), 2, 4)]) == \
+ Polygon(Point(0, 0), Point(2, -2), Point(4, 0), Point(2, 2))
+
+
+def test_encloses():
+ # square with a dimpled left side
+ s = Polygon(Point(0, 0), Point(1, 0), Point(1, 1), Point(0, 1), \
+ Point(S.Half, S.Half))
+ # the following is True if the polygon isn't treated as closing on itself
+ assert s.encloses(Point(0, S.Half)) is False
+ assert s.encloses(Point(S.Half, S.Half)) is False # it's a vertex
+ assert s.encloses(Point(Rational(3, 4), S.Half)) is True
+
+
+def test_triangle_kwargs():
+ assert Triangle(sss=(3, 4, 5)) == \
+ Triangle(Point(0, 0), Point(3, 0), Point(3, 4))
+ assert Triangle(asa=(30, 2, 30)) == \
+ Triangle(Point(0, 0), Point(2, 0), Point(1, sqrt(3)/3))
+ assert Triangle(sas=(1, 45, 2)) == \
+ Triangle(Point(0, 0), Point(2, 0), Point(sqrt(2)/2, sqrt(2)/2))
+ assert Triangle(sss=(1, 2, 5)) is None
+ assert deg(rad(180)) == 180
+
+
+def test_transform():
+ pts = [Point(0, 0), Point(S.Half, Rational(1, 4)), Point(1, 1)]
+ pts_out = [Point(-4, -10), Point(-3, Rational(-37, 4)), Point(-2, -7)]
+ assert Triangle(*pts).scale(2, 3, (4, 5)) == Triangle(*pts_out)
+ assert RegularPolygon((0, 0), 1, 4).scale(2, 3, (4, 5)) == \
+ Polygon(Point(-2, -10), Point(-4, -7), Point(-6, -10), Point(-4, -13))
+ # Checks for symmetric scaling
+ assert RegularPolygon((0, 0), 1, 4).scale(2, 2) == \
+ RegularPolygon(Point2D(0, 0), 2, 4, 0)
+
+def test_reflect():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+ b = Symbol('b')
+ m = Symbol('m')
+ l = Line((0, b), slope=m)
+ p = Point(x, y)
+ r = p.reflect(l)
+ dp = l.perpendicular_segment(p).length
+ dr = l.perpendicular_segment(r).length
+
+ assert verify_numerically(dp, dr)
+
+ assert Polygon((1, 0), (2, 0), (2, 2)).reflect(Line((3, 0), slope=oo)) \
+ == Triangle(Point(5, 0), Point(4, 0), Point(4, 2))
+ assert Polygon((1, 0), (2, 0), (2, 2)).reflect(Line((0, 3), slope=oo)) \
+ == Triangle(Point(-1, 0), Point(-2, 0), Point(-2, 2))
+ assert Polygon((1, 0), (2, 0), (2, 2)).reflect(Line((0, 3), slope=0)) \
+ == Triangle(Point(1, 6), Point(2, 6), Point(2, 4))
+ assert Polygon((1, 0), (2, 0), (2, 2)).reflect(Line((3, 0), slope=0)) \
+ == Triangle(Point(1, 0), Point(2, 0), Point(2, -2))
+
+def test_bisectors():
+ p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+ p = Polygon(Point(0, 0), Point(2, 0), Point(1, 1), Point(0, 3))
+ q = Polygon(Point(1, 0), Point(2, 0), Point(3, 3), Point(-1, 5))
+ poly = Polygon(Point(3, 4), Point(0, 0), Point(8, 7), Point(-1, 1), Point(19, -19))
+ t = Triangle(p1, p2, p3)
+ assert t.bisectors()[p2] == Segment(Point(1, 0), Point(0, sqrt(2) - 1))
+ assert p.bisectors()[Point2D(0, 3)] == Ray2D(Point2D(0, 3), \
+ Point2D(sin(acos(2*sqrt(5)/5)/2), 3 - cos(acos(2*sqrt(5)/5)/2)))
+ assert q.bisectors()[Point2D(-1, 5)] == \
+ Ray2D(Point2D(-1, 5), Point2D(-1 + sqrt(29)*(5*sin(acos(9*sqrt(145)/145)/2) + \
+ 2*cos(acos(9*sqrt(145)/145)/2))/29, sqrt(29)*(-5*cos(acos(9*sqrt(145)/145)/2) + \
+ 2*sin(acos(9*sqrt(145)/145)/2))/29 + 5))
+ assert poly.bisectors()[Point2D(-1, 1)] == Ray2D(Point2D(-1, 1), \
+ Point2D(-1 + sin(acos(sqrt(26)/26)/2 + pi/4), 1 - sin(-acos(sqrt(26)/26)/2 + pi/4)))
+
+def test_incenter():
+ assert Triangle(Point(0, 0), Point(1, 0), Point(0, 1)).incenter \
+ == Point(1 - sqrt(2)/2, 1 - sqrt(2)/2)
+
+def test_inradius():
+ assert Triangle(Point(0, 0), Point(4, 0), Point(0, 3)).inradius == 1
+
+def test_incircle():
+ assert Triangle(Point(0, 0), Point(2, 0), Point(0, 2)).incircle \
+ == Circle(Point(2 - sqrt(2), 2 - sqrt(2)), 2 - sqrt(2))
+
+def test_exradii():
+ t = Triangle(Point(0, 0), Point(6, 0), Point(0, 2))
+ assert t.exradii[t.sides[2]] == (-2 + sqrt(10))
+
+def test_medians():
+ t = Triangle(Point(0, 0), Point(1, 0), Point(0, 1))
+ assert t.medians[Point(0, 0)] == Segment(Point(0, 0), Point(S.Half, S.Half))
+
+def test_medial():
+ assert Triangle(Point(0, 0), Point(1, 0), Point(0, 1)).medial \
+ == Triangle(Point(S.Half, 0), Point(S.Half, S.Half), Point(0, S.Half))
+
+def test_nine_point_circle():
+ assert Triangle(Point(0, 0), Point(1, 0), Point(0, 1)).nine_point_circle \
+ == Circle(Point2D(Rational(1, 4), Rational(1, 4)), sqrt(2)/4)
+
+def test_eulerline():
+ assert Triangle(Point(0, 0), Point(1, 0), Point(0, 1)).eulerline \
+ == Line(Point2D(0, 0), Point2D(S.Half, S.Half))
+ assert Triangle(Point(0, 0), Point(10, 0), Point(5, 5*sqrt(3))).eulerline \
+ == Point2D(5, 5*sqrt(3)/3)
+ assert Triangle(Point(4, -6), Point(4, -1), Point(-3, 3)).eulerline \
+ == Line(Point2D(Rational(64, 7), 3), Point2D(Rational(-29, 14), Rational(-7, 2)))
+
+def test_intersection():
+ poly1 = Triangle(Point(0, 0), Point(1, 0), Point(0, 1))
+ poly2 = Polygon(Point(0, 1), Point(-5, 0),
+ Point(0, -4), Point(0, Rational(1, 5)),
+ Point(S.Half, -0.1), Point(1, 0), Point(0, 1))
+
+ assert poly1.intersection(poly2) == [Point2D(Rational(1, 3), 0),
+ Segment(Point(0, Rational(1, 5)), Point(0, 0)),
+ Segment(Point(1, 0), Point(0, 1))]
+ assert poly2.intersection(poly1) == [Point(Rational(1, 3), 0),
+ Segment(Point(0, 0), Point(0, Rational(1, 5))),
+ Segment(Point(1, 0), Point(0, 1))]
+ assert poly1.intersection(Point(0, 0)) == [Point(0, 0)]
+ assert poly1.intersection(Point(-12, -43)) == []
+ assert poly2.intersection(Line((-12, 0), (12, 0))) == [Point(-5, 0),
+ Point(0, 0), Point(Rational(1, 3), 0), Point(1, 0)]
+ assert poly2.intersection(Line((-12, 12), (12, 12))) == []
+ assert poly2.intersection(Ray((-3, 4), (1, 0))) == [Segment(Point(1, 0),
+ Point(0, 1))]
+ assert poly2.intersection(Circle((0, -1), 1)) == [Point(0, -2),
+ Point(0, 0)]
+ assert poly1.intersection(poly1) == [Segment(Point(0, 0), Point(1, 0)),
+ Segment(Point(0, 1), Point(0, 0)), Segment(Point(1, 0), Point(0, 1))]
+ assert poly2.intersection(poly2) == [Segment(Point(-5, 0), Point(0, -4)),
+ Segment(Point(0, -4), Point(0, Rational(1, 5))),
+ Segment(Point(0, Rational(1, 5)), Point(S.Half, Rational(-1, 10))),
+ Segment(Point(0, 1), Point(-5, 0)),
+ Segment(Point(S.Half, Rational(-1, 10)), Point(1, 0)),
+ Segment(Point(1, 0), Point(0, 1))]
+ assert poly2.intersection(Triangle(Point(0, 1), Point(1, 0), Point(-1, 1))) \
+ == [Point(Rational(-5, 7), Rational(6, 7)), Segment(Point2D(0, 1), Point(1, 0))]
+ assert poly1.intersection(RegularPolygon((-12, -15), 3, 3)) == []
+
+
+def test_parameter_value():
+ t = Symbol('t')
+ sq = Polygon((0, 0), (0, 1), (1, 1), (1, 0))
+ assert sq.parameter_value((0.5, 1), t) == {t: Rational(3, 8)}
+ q = Polygon((0, 0), (2, 1), (2, 4), (4, 0))
+ assert q.parameter_value((4, 0), t) == {t: -6 + 3*sqrt(5)} # ~= 0.708
+
+ raises(ValueError, lambda: sq.parameter_value((5, 6), t))
+ raises(ValueError, lambda: sq.parameter_value(Circle(Point(0, 0), 1), t))
+
+
+def test_issue_12966():
+ poly = Polygon(Point(0, 0), Point(0, 10), Point(5, 10), Point(5, 5),
+ Point(10, 5), Point(10, 0))
+ t = Symbol('t')
+ pt = poly.arbitrary_point(t)
+ DELTA = 5/poly.perimeter
+ assert [pt.subs(t, DELTA*i) for i in range(int(1/DELTA))] == [
+ Point(0, 0), Point(0, 5), Point(0, 10), Point(5, 10),
+ Point(5, 5), Point(10, 5), Point(10, 0), Point(5, 0)]
+
+
+def test_second_moment_of_area():
+ x, y = symbols('x, y')
+ # triangle
+ p1, p2, p3 = [(0, 0), (4, 0), (0, 2)]
+ p = (0, 0)
+ # equation of hypotenuse
+ eq_y = (1-x/4)*2
+ I_yy = integrate((x**2) * (integrate(1, (y, 0, eq_y))), (x, 0, 4))
+ I_xx = integrate(1 * (integrate(y**2, (y, 0, eq_y))), (x, 0, 4))
+ I_xy = integrate(x * (integrate(y, (y, 0, eq_y))), (x, 0, 4))
+
+ triangle = Polygon(p1, p2, p3)
+
+ assert (I_xx - triangle.second_moment_of_area(p)[0]) == 0
+ assert (I_yy - triangle.second_moment_of_area(p)[1]) == 0
+ assert (I_xy - triangle.second_moment_of_area(p)[2]) == 0
+
+ # rectangle
+ p1, p2, p3, p4=[(0, 0), (4, 0), (4, 2), (0, 2)]
+ I_yy = integrate((x**2) * integrate(1, (y, 0, 2)), (x, 0, 4))
+ I_xx = integrate(1 * integrate(y**2, (y, 0, 2)), (x, 0, 4))
+ I_xy = integrate(x * integrate(y, (y, 0, 2)), (x, 0, 4))
+
+ rectangle = Polygon(p1, p2, p3, p4)
+
+ assert (I_xx - rectangle.second_moment_of_area(p)[0]) == 0
+ assert (I_yy - rectangle.second_moment_of_area(p)[1]) == 0
+ assert (I_xy - rectangle.second_moment_of_area(p)[2]) == 0
+
+
+ r = RegularPolygon(Point(0, 0), 5, 3)
+ assert r.second_moment_of_area() == (1875*sqrt(3)/S(32), 1875*sqrt(3)/S(32), 0)
+
+
+def test_first_moment():
+ a, b = symbols('a, b', positive=True)
+ # rectangle
+ p1 = Polygon((0, 0), (a, 0), (a, b), (0, b))
+ assert p1.first_moment_of_area() == (a*b**2/8, a**2*b/8)
+ assert p1.first_moment_of_area((a/3, b/4)) == (-3*a*b**2/32, -a**2*b/9)
+
+ p1 = Polygon((0, 0), (40, 0), (40, 30), (0, 30))
+ assert p1.first_moment_of_area() == (4500, 6000)
+
+ # triangle
+ p2 = Polygon((0, 0), (a, 0), (a/2, b))
+ assert p2.first_moment_of_area() == (4*a*b**2/81, a**2*b/24)
+ assert p2.first_moment_of_area((a/8, b/6)) == (-25*a*b**2/648, -5*a**2*b/768)
+
+ p2 = Polygon((0, 0), (12, 0), (12, 30))
+ assert p2.first_moment_of_area() == (S(1600)/3, -S(640)/3)
+
+
+def test_section_modulus_and_polar_second_moment_of_area():
+ a, b = symbols('a, b', positive=True)
+ x, y = symbols('x, y')
+ rectangle = Polygon((0, b), (0, 0), (a, 0), (a, b))
+ assert rectangle.section_modulus(Point(x, y)) == (a*b**3/12/(-b/2 + y), a**3*b/12/(-a/2 + x))
+ assert rectangle.polar_second_moment_of_area() == a**3*b/12 + a*b**3/12
+
+ convex = RegularPolygon((0, 0), 1, 6)
+ assert convex.section_modulus() == (Rational(5, 8), sqrt(3)*Rational(5, 16))
+ assert convex.polar_second_moment_of_area() == 5*sqrt(3)/S(8)
+
+ concave = Polygon((0, 0), (1, 8), (3, 4), (4, 6), (7, 1))
+ assert concave.section_modulus() == (Rational(-6371, 429), Rational(-9778, 519))
+ assert concave.polar_second_moment_of_area() == Rational(-38669, 252)
+
+
+def test_cut_section():
+ # concave polygon
+ p = Polygon((-1, -1), (1, Rational(5, 2)), (2, 1), (3, Rational(5, 2)), (4, 2), (5, 3), (-1, 3))
+ l = Line((0, 0), (Rational(9, 2), 3))
+ p1 = p.cut_section(l)[0]
+ p2 = p.cut_section(l)[1]
+ assert p1 == Polygon(
+ Point2D(Rational(-9, 13), Rational(-6, 13)), Point2D(1, Rational(5, 2)), Point2D(Rational(24, 13), Rational(16, 13)),
+ Point2D(Rational(12, 5), Rational(8, 5)), Point2D(3, Rational(5, 2)), Point2D(Rational(24, 7), Rational(16, 7)),
+ Point2D(Rational(9, 2), 3), Point2D(-1, 3), Point2D(-1, Rational(-2, 3)))
+ assert p2 == Polygon(Point2D(-1, -1), Point2D(Rational(-9, 13), Rational(-6, 13)), Point2D(Rational(24, 13), Rational(16, 13)),
+ Point2D(2, 1), Point2D(Rational(12, 5), Rational(8, 5)), Point2D(Rational(24, 7), Rational(16, 7)), Point2D(4, 2), Point2D(5, 3),
+ Point2D(Rational(9, 2), 3), Point2D(-1, Rational(-2, 3)))
+
+ # convex polygon
+ p = RegularPolygon(Point2D(0, 0), 6, 6)
+ s = p.cut_section(Line((0, 0), slope=1))
+ assert s[0] == Polygon(Point2D(-3*sqrt(3) + 9, -3*sqrt(3) + 9), Point2D(3, 3*sqrt(3)),
+ Point2D(-3, 3*sqrt(3)), Point2D(-6, 0), Point2D(-9 + 3*sqrt(3), -9 + 3*sqrt(3)))
+ assert s[1] == Polygon(Point2D(6, 0), Point2D(-3*sqrt(3) + 9, -3*sqrt(3) + 9),
+ Point2D(-9 + 3*sqrt(3), -9 + 3*sqrt(3)), Point2D(-3, -3*sqrt(3)), Point2D(3, -3*sqrt(3)))
+
+ # case where line does not intersects but coincides with the edge of polygon
+ a, b = 20, 10
+ t1, t2, t3, t4 = [(0, b), (0, 0), (a, 0), (a, b)]
+ p = Polygon(t1, t2, t3, t4)
+ p1, p2 = p.cut_section(Line((0, b), slope=0))
+ assert p1 == None
+ assert p2 == Polygon(Point2D(0, 10), Point2D(0, 0), Point2D(20, 0), Point2D(20, 10))
+
+ p3, p4 = p.cut_section(Line((0, 0), slope=0))
+ assert p3 == Polygon(Point2D(0, 10), Point2D(0, 0), Point2D(20, 0), Point2D(20, 10))
+ assert p4 == None
+
+ # case where the line does not intersect with a polygon at all
+ raises(ValueError, lambda: p.cut_section(Line((0, a), slope=0)))
+
+def test_type_of_triangle():
+ # Isoceles triangle
+ p1 = Polygon(Point(0, 0), Point(5, 0), Point(2, 4))
+ assert p1.is_isosceles() == True
+ assert p1.is_scalene() == False
+ assert p1.is_equilateral() == False
+
+ # Scalene triangle
+ p2 = Polygon (Point(0, 0), Point(0, 2), Point(4, 0))
+ assert p2.is_isosceles() == False
+ assert p2.is_scalene() == True
+ assert p2.is_equilateral() == False
+
+ # Equilateral triagle
+ p3 = Polygon(Point(0, 0), Point(6, 0), Point(3, sqrt(27)))
+ assert p3.is_isosceles() == True
+ assert p3.is_scalene() == False
+ assert p3.is_equilateral() == True
+
+def test_do_poly_distance():
+ # Non-intersecting polygons
+ square1 = Polygon (Point(0, 0), Point(0, 1), Point(1, 1), Point(1, 0))
+ triangle1 = Polygon(Point(1, 2), Point(2, 2), Point(2, 1))
+ assert square1._do_poly_distance(triangle1) == sqrt(2)/2
+
+ # Polygons which sides intersect
+ square2 = Polygon(Point(1, 0), Point(2, 0), Point(2, 1), Point(1, 1))
+ with warns(UserWarning, \
+ match="Polygons may intersect producing erroneous output", test_stacklevel=False):
+ assert square1._do_poly_distance(square2) == 0
+
+ # Polygons which bodies intersect
+ triangle2 = Polygon(Point(0, -1), Point(2, -1), Point(S.Half, S.Half))
+ with warns(UserWarning, \
+ match="Polygons may intersect producing erroneous output", test_stacklevel=False):
+ assert triangle2._do_poly_distance(square1) == 0
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/tests/test_util.py b/janus/lib/python3.10/site-packages/sympy/geometry/tests/test_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..da52a795a9383c6438ca06303e8ae6506dccdc65
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/geometry/tests/test_util.py
@@ -0,0 +1,170 @@
+import pytest
+from sympy.core.numbers import Float
+from sympy.core.function import (Derivative, Function)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions import exp, cos, sin, tan, cosh, sinh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.geometry import Point, Point2D, Line, Polygon, Segment, convex_hull,\
+ intersection, centroid, Point3D, Line3D, Ray, Ellipse
+from sympy.geometry.util import idiff, closest_points, farthest_points, _ordered_points, are_coplanar
+from sympy.solvers.solvers import solve
+from sympy.testing.pytest import raises
+
+
+def test_idiff():
+ x = Symbol('x', real=True)
+ y = Symbol('y', real=True)
+ t = Symbol('t', real=True)
+ f = Function('f')
+ g = Function('g')
+ # the use of idiff in ellipse also provides coverage
+ circ = x**2 + y**2 - 4
+ ans = -3*x*(x**2/y**2 + 1)/y**3
+ assert ans == idiff(circ, y, x, 3), idiff(circ, y, x, 3)
+ assert ans == idiff(circ, [y], x, 3)
+ assert idiff(circ, y, x, 3) == ans
+ explicit = 12*x/sqrt(-x**2 + 4)**5
+ assert ans.subs(y, solve(circ, y)[0]).equals(explicit)
+ assert True in [sol.diff(x, 3).equals(explicit) for sol in solve(circ, y)]
+ assert idiff(x + t + y, [y, t], x) == -Derivative(t, x) - 1
+ assert idiff(f(x) * exp(f(x)) - x * exp(x), f(x), x) == (x + 1)*exp(x)*exp(-f(x))/(f(x) + 1)
+ assert idiff(f(x) - y * exp(x), [f(x), y], x) == (y + Derivative(y, x))*exp(x)
+ assert idiff(f(x) - y * exp(x), [y, f(x)], x) == -y + Derivative(f(x), x)*exp(-x)
+ assert idiff(f(x) - g(x), [f(x), g(x)], x) == Derivative(g(x), x)
+ # this should be fast
+ fxy = y - (-10*(-sin(x) + 1/x)**2 + tan(x)**2 + 2*cosh(x/10))
+ assert idiff(fxy, y, x) == -20*sin(x)*cos(x) + 2*tan(x)**3 + \
+ 2*tan(x) + sinh(x/10)/5 + 20*cos(x)/x - 20*sin(x)/x**2 + 20/x**3
+
+
+def test_intersection():
+ assert intersection(Point(0, 0)) == []
+ raises(TypeError, lambda: intersection(Point(0, 0), 3))
+ assert intersection(
+ Segment((0, 0), (2, 0)),
+ Segment((-1, 0), (1, 0)),
+ Line((0, 0), (0, 1)), pairwise=True) == [
+ Point(0, 0), Segment((0, 0), (1, 0))]
+ assert intersection(
+ Line((0, 0), (0, 1)),
+ Segment((0, 0), (2, 0)),
+ Segment((-1, 0), (1, 0)), pairwise=True) == [
+ Point(0, 0), Segment((0, 0), (1, 0))]
+ assert intersection(
+ Line((0, 0), (0, 1)),
+ Segment((0, 0), (2, 0)),
+ Segment((-1, 0), (1, 0)),
+ Line((0, 0), slope=1), pairwise=True) == [
+ Point(0, 0), Segment((0, 0), (1, 0))]
+ R = 4.0
+ c = intersection(
+ Ray(Point2D(0.001, -1),
+ Point2D(0.0008, -1.7)),
+ Ellipse(center=Point2D(0, 0), hradius=R, vradius=2.0), pairwise=True)[0].coordinates
+ assert c == pytest.approx(
+ Point2D(0.000714285723396502, -1.99999996811224, evaluate=False).coordinates)
+ # check this is responds to a lower precision parameter
+ R = Float(4, 5)
+ c2 = intersection(
+ Ray(Point2D(0.001, -1),
+ Point2D(0.0008, -1.7)),
+ Ellipse(center=Point2D(0, 0), hradius=R, vradius=2.0), pairwise=True)[0].coordinates
+ assert c2 == pytest.approx(
+ Point2D(0.000714285723396502, -1.99999996811224, evaluate=False).coordinates)
+ assert c[0]._prec == 53
+ assert c2[0]._prec == 20
+
+
+def test_convex_hull():
+ raises(TypeError, lambda: convex_hull(Point(0, 0), 3))
+ points = [(1, -1), (1, -2), (3, -1), (-5, -2), (15, -4)]
+ assert convex_hull(*points, **{"polygon": False}) == (
+ [Point2D(-5, -2), Point2D(1, -1), Point2D(3, -1), Point2D(15, -4)],
+ [Point2D(-5, -2), Point2D(15, -4)])
+
+
+def test_centroid():
+ p = Polygon((0, 0), (10, 0), (10, 10))
+ q = p.translate(0, 20)
+ assert centroid(p, q) == Point(20, 40)/3
+ p = Segment((0, 0), (2, 0))
+ q = Segment((0, 0), (2, 2))
+ assert centroid(p, q) == Point(1, -sqrt(2) + 2)
+ assert centroid(Point(0, 0), Point(2, 0)) == Point(2, 0)/2
+ assert centroid(Point(0, 0), Point(0, 0), Point(2, 0)) == Point(2, 0)/3
+
+
+def test_farthest_points_closest_points():
+ from sympy.core.random import randint
+ from sympy.utilities.iterables import subsets
+
+ for how in (min, max):
+ if how == min:
+ func = closest_points
+ else:
+ func = farthest_points
+
+ raises(ValueError, lambda: func(Point2D(0, 0), Point2D(0, 0)))
+
+ # 3rd pt dx is close and pt is closer to 1st pt
+ p1 = [Point2D(0, 0), Point2D(3, 0), Point2D(1, 1)]
+ # 3rd pt dx is close and pt is closer to 2nd pt
+ p2 = [Point2D(0, 0), Point2D(3, 0), Point2D(2, 1)]
+ # 3rd pt dx is close and but pt is not closer
+ p3 = [Point2D(0, 0), Point2D(3, 0), Point2D(1, 10)]
+ # 3rd pt dx is not closer and it's closer to 2nd pt
+ p4 = [Point2D(0, 0), Point2D(3, 0), Point2D(4, 0)]
+ # 3rd pt dx is not closer and it's closer to 1st pt
+ p5 = [Point2D(0, 0), Point2D(3, 0), Point2D(-1, 0)]
+ # duplicate point doesn't affect outcome
+ dup = [Point2D(0, 0), Point2D(3, 0), Point2D(3, 0), Point2D(-1, 0)]
+ # symbolic
+ x = Symbol('x', positive=True)
+ s = [Point2D(a) for a in ((x, 1), (x + 3, 2), (x + 2, 2))]
+
+ for points in (p1, p2, p3, p4, p5, dup, s):
+ d = how(i.distance(j) for i, j in subsets(set(points), 2))
+ ans = a, b = list(func(*points))[0]
+ assert a.distance(b) == d
+ assert ans == _ordered_points(ans)
+
+ # if the following ever fails, the above tests were not sufficient
+ # and the logical error in the routine should be fixed
+ points = set()
+ while len(points) != 7:
+ points.add(Point2D(randint(1, 100), randint(1, 100)))
+ points = list(points)
+ d = how(i.distance(j) for i, j in subsets(points, 2))
+ ans = a, b = list(func(*points))[0]
+ assert a.distance(b) == d
+ assert ans == _ordered_points(ans)
+
+ # equidistant points
+ a, b, c = (
+ Point2D(0, 0), Point2D(1, 0), Point2D(S.Half, sqrt(3)/2))
+ ans = {_ordered_points((i, j))
+ for i, j in subsets((a, b, c), 2)}
+ assert closest_points(b, c, a) == ans
+ assert farthest_points(b, c, a) == ans
+
+ # unique to farthest
+ points = [(1, 1), (1, 2), (3, 1), (-5, 2), (15, 4)]
+ assert farthest_points(*points) == {
+ (Point2D(-5, 2), Point2D(15, 4))}
+ points = [(1, -1), (1, -2), (3, -1), (-5, -2), (15, -4)]
+ assert farthest_points(*points) == {
+ (Point2D(-5, -2), Point2D(15, -4))}
+ assert farthest_points((1, 1), (0, 0)) == {
+ (Point2D(0, 0), Point2D(1, 1))}
+ raises(ValueError, lambda: farthest_points((1, 1)))
+
+
+def test_are_coplanar():
+ a = Line3D(Point3D(5, 0, 0), Point3D(1, -1, 1))
+ b = Line3D(Point3D(0, -2, 0), Point3D(3, 1, 1))
+ c = Line3D(Point3D(0, -1, 0), Point3D(5, -1, 9))
+ d = Line(Point2D(0, 3), Point2D(1, 5))
+
+ assert are_coplanar(a, b, c) == False
+ assert are_coplanar(a, d) == False
diff --git a/janus/lib/python3.10/site-packages/sympy/geometry/util.py b/janus/lib/python3.10/site-packages/sympy/geometry/util.py
new file mode 100644
index 0000000000000000000000000000000000000000..edded73c71e21f1f855114ab3777dd67765dd926
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/geometry/util.py
@@ -0,0 +1,733 @@
+"""Utility functions for geometrical entities.
+
+Contains
+========
+intersection
+convex_hull
+closest_points
+farthest_points
+are_coplanar
+are_similar
+
+"""
+
+from collections import deque
+from math import sqrt as _sqrt
+
+from sympy import nsimplify
+from .entity import GeometryEntity
+from .exceptions import GeometryError
+from .point import Point, Point2D, Point3D
+from sympy.core.containers import OrderedSet
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import Function, expand_mul
+from sympy.core.numbers import Float
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Symbol
+from sympy.core.singleton import S
+from sympy.polys.polytools import cancel
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.utilities.iterables import is_sequence
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+def find(x, equation):
+ """
+ Checks whether a Symbol matching ``x`` is present in ``equation``
+ or not. If present, the matching symbol is returned, else a
+ ValueError is raised. If ``x`` is a string the matching symbol
+ will have the same name; if ``x`` is a Symbol then it will be
+ returned if found.
+
+ Examples
+ ========
+
+ >>> from sympy.geometry.util import find
+ >>> from sympy import Dummy
+ >>> from sympy.abc import x
+ >>> find('x', x)
+ x
+ >>> find('x', Dummy('x'))
+ _x
+
+ The dummy symbol is returned since it has a matching name:
+
+ >>> _.name == 'x'
+ True
+ >>> find(x, Dummy('x'))
+ Traceback (most recent call last):
+ ...
+ ValueError: could not find x
+ """
+
+ free = equation.free_symbols
+ xs = [i for i in free if (i.name if isinstance(x, str) else i) == x]
+ if not xs:
+ raise ValueError('could not find %s' % x)
+ if len(xs) != 1:
+ raise ValueError('ambiguous %s' % x)
+ return xs[0]
+
+
+def _ordered_points(p):
+ """Return the tuple of points sorted numerically according to args"""
+ return tuple(sorted(p, key=lambda x: x.args))
+
+
+def are_coplanar(*e):
+ """ Returns True if the given entities are coplanar otherwise False
+
+ Parameters
+ ==========
+
+ e: entities to be checked for being coplanar
+
+ Returns
+ =======
+
+ Boolean
+
+ Examples
+ ========
+
+ >>> from sympy import Point3D, Line3D
+ >>> from sympy.geometry.util import are_coplanar
+ >>> a = Line3D(Point3D(5, 0, 0), Point3D(1, -1, 1))
+ >>> b = Line3D(Point3D(0, -2, 0), Point3D(3, 1, 1))
+ >>> c = Line3D(Point3D(0, -1, 0), Point3D(5, -1, 9))
+ >>> are_coplanar(a, b, c)
+ False
+
+ """
+ from .line import LinearEntity3D
+ from .plane import Plane
+ # XXX update tests for coverage
+
+ e = set(e)
+ # first work with a Plane if present
+ for i in list(e):
+ if isinstance(i, Plane):
+ e.remove(i)
+ return all(p.is_coplanar(i) for p in e)
+
+ if all(isinstance(i, Point3D) for i in e):
+ if len(e) < 3:
+ return False
+
+ # remove pts that are collinear with 2 pts
+ a, b = e.pop(), e.pop()
+ for i in list(e):
+ if Point3D.are_collinear(a, b, i):
+ e.remove(i)
+
+ if not e:
+ return False
+ else:
+ # define a plane
+ p = Plane(a, b, e.pop())
+ for i in e:
+ if i not in p:
+ return False
+ return True
+ else:
+ pt3d = []
+ for i in e:
+ if isinstance(i, Point3D):
+ pt3d.append(i)
+ elif isinstance(i, LinearEntity3D):
+ pt3d.extend(i.args)
+ elif isinstance(i, GeometryEntity): # XXX we should have a GeometryEntity3D class so we can tell the difference between 2D and 3D -- here we just want to deal with 2D objects; if new 3D objects are encountered that we didn't handle above, an error should be raised
+ # all 2D objects have some Point that defines them; so convert those points to 3D pts by making z=0
+ for p in i.args:
+ if isinstance(p, Point):
+ pt3d.append(Point3D(*(p.args + (0,))))
+ return are_coplanar(*pt3d)
+
+
+def are_similar(e1, e2):
+ """Are two geometrical entities similar.
+
+ Can one geometrical entity be uniformly scaled to the other?
+
+ Parameters
+ ==========
+
+ e1 : GeometryEntity
+ e2 : GeometryEntity
+
+ Returns
+ =======
+
+ are_similar : boolean
+
+ Raises
+ ======
+
+ GeometryError
+ When `e1` and `e2` cannot be compared.
+
+ Notes
+ =====
+
+ If the two objects are equal then they are similar.
+
+ See Also
+ ========
+
+ sympy.geometry.entity.GeometryEntity.is_similar
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Circle, Triangle, are_similar
+ >>> c1, c2 = Circle(Point(0, 0), 4), Circle(Point(1, 4), 3)
+ >>> t1 = Triangle(Point(0, 0), Point(1, 0), Point(0, 1))
+ >>> t2 = Triangle(Point(0, 0), Point(2, 0), Point(0, 2))
+ >>> t3 = Triangle(Point(0, 0), Point(3, 0), Point(0, 1))
+ >>> are_similar(t1, t2)
+ True
+ >>> are_similar(t1, t3)
+ False
+
+ """
+ if e1 == e2:
+ return True
+ is_similar1 = getattr(e1, 'is_similar', None)
+ if is_similar1:
+ return is_similar1(e2)
+ is_similar2 = getattr(e2, 'is_similar', None)
+ if is_similar2:
+ return is_similar2(e1)
+ n1 = e1.__class__.__name__
+ n2 = e2.__class__.__name__
+ raise GeometryError(
+ "Cannot test similarity between %s and %s" % (n1, n2))
+
+
+def centroid(*args):
+ """Find the centroid (center of mass) of the collection containing only Points,
+ Segments or Polygons. The centroid is the weighted average of the individual centroid
+ where the weights are the lengths (of segments) or areas (of polygons).
+ Overlapping regions will add to the weight of that region.
+
+ If there are no objects (or a mixture of objects) then None is returned.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, sympy.geometry.line.Segment,
+ sympy.geometry.polygon.Polygon
+
+ Examples
+ ========
+
+ >>> from sympy import Point, Segment, Polygon
+ >>> from sympy.geometry.util import centroid
+ >>> p = Polygon((0, 0), (10, 0), (10, 10))
+ >>> q = p.translate(0, 20)
+ >>> p.centroid, q.centroid
+ (Point2D(20/3, 10/3), Point2D(20/3, 70/3))
+ >>> centroid(p, q)
+ Point2D(20/3, 40/3)
+ >>> p, q = Segment((0, 0), (2, 0)), Segment((0, 0), (2, 2))
+ >>> centroid(p, q)
+ Point2D(1, 2 - sqrt(2))
+ >>> centroid(Point(0, 0), Point(2, 0))
+ Point2D(1, 0)
+
+ Stacking 3 polygons on top of each other effectively triples the
+ weight of that polygon:
+
+ >>> p = Polygon((0, 0), (1, 0), (1, 1), (0, 1))
+ >>> q = Polygon((1, 0), (3, 0), (3, 1), (1, 1))
+ >>> centroid(p, q)
+ Point2D(3/2, 1/2)
+ >>> centroid(p, p, p, q) # centroid x-coord shifts left
+ Point2D(11/10, 1/2)
+
+ Stacking the squares vertically above and below p has the same
+ effect:
+
+ >>> centroid(p, p.translate(0, 1), p.translate(0, -1), q)
+ Point2D(11/10, 1/2)
+
+ """
+ from .line import Segment
+ from .polygon import Polygon
+ if args:
+ if all(isinstance(g, Point) for g in args):
+ c = Point(0, 0)
+ for g in args:
+ c += g
+ den = len(args)
+ elif all(isinstance(g, Segment) for g in args):
+ c = Point(0, 0)
+ L = 0
+ for g in args:
+ l = g.length
+ c += g.midpoint*l
+ L += l
+ den = L
+ elif all(isinstance(g, Polygon) for g in args):
+ c = Point(0, 0)
+ A = 0
+ for g in args:
+ a = g.area
+ c += g.centroid*a
+ A += a
+ den = A
+ c /= den
+ return c.func(*[i.simplify() for i in c.args])
+
+
+def closest_points(*args):
+ """Return the subset of points from a set of points that were
+ the closest to each other in the 2D plane.
+
+ Parameters
+ ==========
+
+ args
+ A collection of Points on 2D plane.
+
+ Notes
+ =====
+
+ This can only be performed on a set of points whose coordinates can
+ be ordered on the number line. If there are no ties then a single
+ pair of Points will be in the set.
+
+ Examples
+ ========
+
+ >>> from sympy import closest_points, Triangle
+ >>> Triangle(sss=(3, 4, 5)).args
+ (Point2D(0, 0), Point2D(3, 0), Point2D(3, 4))
+ >>> closest_points(*_)
+ {(Point2D(0, 0), Point2D(3, 0))}
+
+ References
+ ==========
+
+ .. [1] https://www.cs.mcgill.ca/~cs251/ClosestPair/ClosestPairPS.html
+
+ .. [2] Sweep line algorithm
+ https://en.wikipedia.org/wiki/Sweep_line_algorithm
+
+ """
+ p = [Point2D(i) for i in set(args)]
+ if len(p) < 2:
+ raise ValueError('At least 2 distinct points must be given.')
+
+ try:
+ p.sort(key=lambda x: x.args)
+ except TypeError:
+ raise ValueError("The points could not be sorted.")
+
+ if not all(i.is_Rational for j in p for i in j.args):
+ def hypot(x, y):
+ arg = x*x + y*y
+ if arg.is_Rational:
+ return _sqrt(arg)
+ return sqrt(arg)
+ else:
+ from math import hypot
+
+ rv = [(0, 1)]
+ best_dist = hypot(p[1].x - p[0].x, p[1].y - p[0].y)
+ i = 2
+ left = 0
+ box = deque([0, 1])
+ while i < len(p):
+ while left < i and p[i][0] - p[left][0] > best_dist:
+ box.popleft()
+ left += 1
+
+ for j in box:
+ d = hypot(p[i].x - p[j].x, p[i].y - p[j].y)
+ if d < best_dist:
+ rv = [(j, i)]
+ elif d == best_dist:
+ rv.append((j, i))
+ else:
+ continue
+ best_dist = d
+ box.append(i)
+ i += 1
+
+ return {tuple([p[i] for i in pair]) for pair in rv}
+
+
+def convex_hull(*args, polygon=True):
+ """The convex hull surrounding the Points contained in the list of entities.
+
+ Parameters
+ ==========
+
+ args : a collection of Points, Segments and/or Polygons
+
+ Optional parameters
+ ===================
+
+ polygon : Boolean. If True, returns a Polygon, if false a tuple, see below.
+ Default is True.
+
+ Returns
+ =======
+
+ convex_hull : Polygon if ``polygon`` is True else as a tuple `(U, L)` where
+ ``L`` and ``U`` are the lower and upper hulls, respectively.
+
+ Notes
+ =====
+
+ This can only be performed on a set of points whose coordinates can
+ be ordered on the number line.
+
+ See Also
+ ========
+
+ sympy.geometry.point.Point, sympy.geometry.polygon.Polygon
+
+ Examples
+ ========
+
+ >>> from sympy import convex_hull
+ >>> points = [(1, 1), (1, 2), (3, 1), (-5, 2), (15, 4)]
+ >>> convex_hull(*points)
+ Polygon(Point2D(-5, 2), Point2D(1, 1), Point2D(3, 1), Point2D(15, 4))
+ >>> convex_hull(*points, **dict(polygon=False))
+ ([Point2D(-5, 2), Point2D(15, 4)],
+ [Point2D(-5, 2), Point2D(1, 1), Point2D(3, 1), Point2D(15, 4)])
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Graham_scan
+
+ .. [2] Andrew's Monotone Chain Algorithm
+ (A.M. Andrew,
+ "Another Efficient Algorithm for Convex Hulls in Two Dimensions", 1979)
+ https://web.archive.org/web/20210511015444/http://geomalgorithms.com/a10-_hull-1.html
+
+ """
+ from .line import Segment
+ from .polygon import Polygon
+ p = OrderedSet()
+ for e in args:
+ if not isinstance(e, GeometryEntity):
+ try:
+ e = Point(e)
+ except NotImplementedError:
+ raise ValueError('%s is not a GeometryEntity and cannot be made into Point' % str(e))
+ if isinstance(e, Point):
+ p.add(e)
+ elif isinstance(e, Segment):
+ p.update(e.points)
+ elif isinstance(e, Polygon):
+ p.update(e.vertices)
+ else:
+ raise NotImplementedError(
+ 'Convex hull for %s not implemented.' % type(e))
+
+ # make sure all our points are of the same dimension
+ if any(len(x) != 2 for x in p):
+ raise ValueError('Can only compute the convex hull in two dimensions')
+
+ p = list(p)
+ if len(p) == 1:
+ return p[0] if polygon else (p[0], None)
+ elif len(p) == 2:
+ s = Segment(p[0], p[1])
+ return s if polygon else (s, None)
+
+ def _orientation(p, q, r):
+ '''Return positive if p-q-r are clockwise, neg if ccw, zero if
+ collinear.'''
+ return (q.y - p.y)*(r.x - p.x) - (q.x - p.x)*(r.y - p.y)
+
+ # scan to find upper and lower convex hulls of a set of 2d points.
+ U = []
+ L = []
+ try:
+ p.sort(key=lambda x: x.args)
+ except TypeError:
+ raise ValueError("The points could not be sorted.")
+ for p_i in p:
+ while len(U) > 1 and _orientation(U[-2], U[-1], p_i) <= 0:
+ U.pop()
+ while len(L) > 1 and _orientation(L[-2], L[-1], p_i) >= 0:
+ L.pop()
+ U.append(p_i)
+ L.append(p_i)
+ U.reverse()
+ convexHull = tuple(L + U[1:-1])
+
+ if len(convexHull) == 2:
+ s = Segment(convexHull[0], convexHull[1])
+ return s if polygon else (s, None)
+ if polygon:
+ return Polygon(*convexHull)
+ else:
+ U.reverse()
+ return (U, L)
+
+def farthest_points(*args):
+ """Return the subset of points from a set of points that were
+ the furthest apart from each other in the 2D plane.
+
+ Parameters
+ ==========
+
+ args
+ A collection of Points on 2D plane.
+
+ Notes
+ =====
+
+ This can only be performed on a set of points whose coordinates can
+ be ordered on the number line. If there are no ties then a single
+ pair of Points will be in the set.
+
+ Examples
+ ========
+
+ >>> from sympy.geometry import farthest_points, Triangle
+ >>> Triangle(sss=(3, 4, 5)).args
+ (Point2D(0, 0), Point2D(3, 0), Point2D(3, 4))
+ >>> farthest_points(*_)
+ {(Point2D(0, 0), Point2D(3, 4))}
+
+ References
+ ==========
+
+ .. [1] https://code.activestate.com/recipes/117225-convex-hull-and-diameter-of-2d-point-sets/
+
+ .. [2] Rotating Callipers Technique
+ https://en.wikipedia.org/wiki/Rotating_calipers
+
+ """
+
+ def rotatingCalipers(Points):
+ U, L = convex_hull(*Points, **{"polygon": False})
+
+ if L is None:
+ if isinstance(U, Point):
+ raise ValueError('At least two distinct points must be given.')
+ yield U.args
+ else:
+ i = 0
+ j = len(L) - 1
+ while i < len(U) - 1 or j > 0:
+ yield U[i], L[j]
+ # if all the way through one side of hull, advance the other side
+ if i == len(U) - 1:
+ j -= 1
+ elif j == 0:
+ i += 1
+ # still points left on both lists, compare slopes of next hull edges
+ # being careful to avoid divide-by-zero in slope calculation
+ elif (U[i+1].y - U[i].y) * (L[j].x - L[j-1].x) > \
+ (L[j].y - L[j-1].y) * (U[i+1].x - U[i].x):
+ i += 1
+ else:
+ j -= 1
+
+ p = [Point2D(i) for i in set(args)]
+
+ if not all(i.is_Rational for j in p for i in j.args):
+ def hypot(x, y):
+ arg = x*x + y*y
+ if arg.is_Rational:
+ return _sqrt(arg)
+ return sqrt(arg)
+ else:
+ from math import hypot
+
+ rv = []
+ diam = 0
+ for pair in rotatingCalipers(args):
+ h, q = _ordered_points(pair)
+ d = hypot(h.x - q.x, h.y - q.y)
+ if d > diam:
+ rv = [(h, q)]
+ elif d == diam:
+ rv.append((h, q))
+ else:
+ continue
+ diam = d
+
+ return set(rv)
+
+
+def idiff(eq, y, x, n=1):
+ """Return ``dy/dx`` assuming that ``eq == 0``.
+
+ Parameters
+ ==========
+
+ y : the dependent variable or a list of dependent variables (with y first)
+ x : the variable that the derivative is being taken with respect to
+ n : the order of the derivative (default is 1)
+
+ Examples
+ ========
+
+ >>> from sympy.abc import x, y, a
+ >>> from sympy.geometry.util import idiff
+
+ >>> circ = x**2 + y**2 - 4
+ >>> idiff(circ, y, x)
+ -x/y
+ >>> idiff(circ, y, x, 2).simplify()
+ (-x**2 - y**2)/y**3
+
+ Here, ``a`` is assumed to be independent of ``x``:
+
+ >>> idiff(x + a + y, y, x)
+ -1
+
+ Now the x-dependence of ``a`` is made explicit by listing ``a`` after
+ ``y`` in a list.
+
+ >>> idiff(x + a + y, [y, a], x)
+ -Derivative(a, x) - 1
+
+ See Also
+ ========
+
+ sympy.core.function.Derivative: represents unevaluated derivatives
+ sympy.core.function.diff: explicitly differentiates wrt symbols
+
+ """
+ if is_sequence(y):
+ dep = set(y)
+ y = y[0]
+ elif isinstance(y, Symbol):
+ dep = {y}
+ elif isinstance(y, Function):
+ pass
+ else:
+ raise ValueError("expecting x-dependent symbol(s) or function(s) but got: %s" % y)
+
+ f = {s: Function(s.name)(x) for s in eq.free_symbols
+ if s != x and s in dep}
+
+ if isinstance(y, Symbol):
+ dydx = Function(y.name)(x).diff(x)
+ else:
+ dydx = y.diff(x)
+
+ eq = eq.subs(f)
+ derivs = {}
+ for i in range(n):
+ # equation will be linear in dydx, a*dydx + b, so dydx = -b/a
+ deq = eq.diff(x)
+ b = deq.xreplace({dydx: S.Zero})
+ a = (deq - b).xreplace({dydx: S.One})
+ yp = factor_terms(expand_mul(cancel((-b/a).subs(derivs)), deep=False))
+ if i == n - 1:
+ return yp.subs([(v, k) for k, v in f.items()])
+ derivs[dydx] = yp
+ eq = dydx - yp
+ dydx = dydx.diff(x)
+
+
+def intersection(*entities, pairwise=False, **kwargs):
+ """The intersection of a collection of GeometryEntity instances.
+
+ Parameters
+ ==========
+ entities : sequence of GeometryEntity
+ pairwise (keyword argument) : Can be either True or False
+
+ Returns
+ =======
+ intersection : list of GeometryEntity
+
+ Raises
+ ======
+ NotImplementedError
+ When unable to calculate intersection.
+
+ Notes
+ =====
+ The intersection of any geometrical entity with itself should return
+ a list with one item: the entity in question.
+ An intersection requires two or more entities. If only a single
+ entity is given then the function will return an empty list.
+ It is possible for `intersection` to miss intersections that one
+ knows exists because the required quantities were not fully
+ simplified internally.
+ Reals should be converted to Rationals, e.g. Rational(str(real_num))
+ or else failures due to floating point issues may result.
+
+ Case 1: When the keyword argument 'pairwise' is False (default value):
+ In this case, the function returns a list of intersections common to
+ all entities.
+
+ Case 2: When the keyword argument 'pairwise' is True:
+ In this case, the functions returns a list intersections that occur
+ between any pair of entities.
+
+ See Also
+ ========
+
+ sympy.geometry.entity.GeometryEntity.intersection
+
+ Examples
+ ========
+
+ >>> from sympy import Ray, Circle, intersection
+ >>> c = Circle((0, 1), 1)
+ >>> intersection(c, c.center)
+ []
+ >>> right = Ray((0, 0), (1, 0))
+ >>> up = Ray((0, 0), (0, 1))
+ >>> intersection(c, right, up)
+ [Point2D(0, 0)]
+ >>> intersection(c, right, up, pairwise=True)
+ [Point2D(0, 0), Point2D(0, 2)]
+ >>> left = Ray((1, 0), (0, 0))
+ >>> intersection(right, left)
+ [Segment2D(Point2D(0, 0), Point2D(1, 0))]
+
+ """
+ if len(entities) <= 1:
+ return []
+
+ entities = list(entities)
+ prec = None
+ for i, e in enumerate(entities):
+ if not isinstance(e, GeometryEntity):
+ # entities may be an immutable tuple
+ e = Point(e)
+ # convert to exact Rationals
+ d = {}
+ for f in e.atoms(Float):
+ prec = f._prec if prec is None else min(f._prec, prec)
+ d.setdefault(f, nsimplify(f, rational=True))
+ entities[i] = e.xreplace(d)
+
+ if not pairwise:
+ # find the intersection common to all objects
+ res = entities[0].intersection(entities[1])
+ for entity in entities[2:]:
+ newres = []
+ for x in res:
+ newres.extend(x.intersection(entity))
+ res = newres
+ else:
+ # find all pairwise intersections
+ ans = []
+ for j in range(len(entities)):
+ for k in range(j + 1, len(entities)):
+ ans.extend(intersection(entities[j], entities[k]))
+ res = list(ordered(set(ans)))
+
+ # convert back to Floats
+ if prec is not None:
+ p = prec_to_dps(prec)
+ res = [i.n(p) for i in res]
+ return res
diff --git a/janus/lib/python3.10/site-packages/sympy/matrices/tests/__pycache__/test_matrixbase.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/matrices/tests/__pycache__/test_matrixbase.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d9e1a5dd9ace475256a3d6d1ef634330be0f15bb
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/matrices/tests/__pycache__/test_matrixbase.cpython-310.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:087c01e2aa001865dd28c5a89adaa64a7339983a4e434c928f1a170738b45405
+size 153933
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/__init__.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1289284bece0c78ba8d304baae2ef59cce974a11
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/__init__.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/hyperexpand.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/hyperexpand.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7ffe16074f088a8eecaa3c3ac4fbd2a25222caac
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/hyperexpand.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/powsimp.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/powsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..484a9f8f0e02d61cce22060dffd344f75a639e06
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/powsimp.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/radsimp.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/radsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ca5949b100365dbf72b4f8dc77b2c34d4f809856
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/radsimp.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/ratsimp.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/ratsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8fd82496ca40224331d633e4df6fce3a9198949b
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/ratsimp.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/simplify.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/simplify.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ad5f432f9fb34b5fe0f475a7979382548b663e7f
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/__pycache__/simplify.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/cse_opts.py b/janus/lib/python3.10/site-packages/sympy/simplify/cse_opts.py
new file mode 100644
index 0000000000000000000000000000000000000000..36a59857411de740ae47423442af88b118a3395d
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/simplify/cse_opts.py
@@ -0,0 +1,52 @@
+""" Optimizations of the expression tree representation for better CSE
+opportunities.
+"""
+from sympy.core import Add, Basic, Mul
+from sympy.core.singleton import S
+from sympy.core.sorting import default_sort_key
+from sympy.core.traversal import preorder_traversal
+
+
+def sub_pre(e):
+ """ Replace y - x with -(x - y) if -1 can be extracted from y - x.
+ """
+ # replacing Add, A, from which -1 can be extracted with -1*-A
+ adds = [a for a in e.atoms(Add) if a.could_extract_minus_sign()]
+ reps = {}
+ ignore = set()
+ for a in adds:
+ na = -a
+ if na.is_Mul: # e.g. MatExpr
+ ignore.add(a)
+ continue
+ reps[a] = Mul._from_args([S.NegativeOne, na])
+
+ e = e.xreplace(reps)
+
+ # repeat again for persisting Adds but mark these with a leading 1, -1
+ # e.g. y - x -> 1*-1*(x - y)
+ if isinstance(e, Basic):
+ negs = {}
+ for a in sorted(e.atoms(Add), key=default_sort_key):
+ if a in ignore:
+ continue
+ if a in reps:
+ negs[a] = reps[a]
+ elif a.could_extract_minus_sign():
+ negs[a] = Mul._from_args([S.One, S.NegativeOne, -a])
+ e = e.xreplace(negs)
+ return e
+
+
+def sub_post(e):
+ """ Replace 1*-1*x with -x.
+ """
+ replacements = []
+ for node in preorder_traversal(e):
+ if isinstance(node, Mul) and \
+ node.args[0] is S.One and node.args[1] is S.NegativeOne:
+ replacements.append((node, -Mul._from_args(node.args[2:])))
+ for node, replacement in replacements:
+ e = e.xreplace({node: replacement})
+
+ return e
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/fu.py b/janus/lib/python3.10/site-packages/sympy/simplify/fu.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd66c2c16193684259e779819fd5e991cdb572bf
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/simplify/fu.py
@@ -0,0 +1,2111 @@
+from collections import defaultdict
+
+from sympy.core.add import Add
+from sympy.core.expr import Expr
+from sympy.core.exprtools import Factors, gcd_terms, factor_terms
+from sympy.core.function import expand_mul
+from sympy.core.mul import Mul
+from sympy.core.numbers import pi, I
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify
+from sympy.core.traversal import bottom_up
+from sympy.functions.combinatorial.factorials import binomial
+from sympy.functions.elementary.hyperbolic import (
+ cosh, sinh, tanh, coth, sech, csch, HyperbolicFunction)
+from sympy.functions.elementary.trigonometric import (
+ cos, sin, tan, cot, sec, csc, sqrt, TrigonometricFunction)
+from sympy.ntheory.factor_ import perfect_power
+from sympy.polys.polytools import factor
+from sympy.strategies.tree import greedy
+from sympy.strategies.core import identity, debug
+
+from sympy import SYMPY_DEBUG
+
+
+# ================== Fu-like tools ===========================
+
+
+def TR0(rv):
+ """Simplification of rational polynomials, trying to simplify
+ the expression, e.g. combine things like 3*x + 2*x, etc....
+ """
+ # although it would be nice to use cancel, it doesn't work
+ # with noncommutatives
+ return rv.normal().factor().expand()
+
+
+def TR1(rv):
+ """Replace sec, csc with 1/cos, 1/sin
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR1, sec, csc
+ >>> from sympy.abc import x
+ >>> TR1(2*csc(x) + sec(x))
+ 1/cos(x) + 2/sin(x)
+ """
+
+ def f(rv):
+ if isinstance(rv, sec):
+ a = rv.args[0]
+ return S.One/cos(a)
+ elif isinstance(rv, csc):
+ a = rv.args[0]
+ return S.One/sin(a)
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def TR2(rv):
+ """Replace tan and cot with sin/cos and cos/sin
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR2
+ >>> from sympy.abc import x
+ >>> from sympy import tan, cot, sin, cos
+ >>> TR2(tan(x))
+ sin(x)/cos(x)
+ >>> TR2(cot(x))
+ cos(x)/sin(x)
+ >>> TR2(tan(tan(x) - sin(x)/cos(x)))
+ 0
+
+ """
+
+ def f(rv):
+ if isinstance(rv, tan):
+ a = rv.args[0]
+ return sin(a)/cos(a)
+ elif isinstance(rv, cot):
+ a = rv.args[0]
+ return cos(a)/sin(a)
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def TR2i(rv, half=False):
+ """Converts ratios involving sin and cos as follows::
+ sin(x)/cos(x) -> tan(x)
+ sin(x)/(cos(x) + 1) -> tan(x/2) if half=True
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR2i
+ >>> from sympy.abc import x, a
+ >>> from sympy import sin, cos
+ >>> TR2i(sin(x)/cos(x))
+ tan(x)
+
+ Powers of the numerator and denominator are also recognized
+
+ >>> TR2i(sin(x)**2/(cos(x) + 1)**2, half=True)
+ tan(x/2)**2
+
+ The transformation does not take place unless assumptions allow
+ (i.e. the base must be positive or the exponent must be an integer
+ for both numerator and denominator)
+
+ >>> TR2i(sin(x)**a/(cos(x) + 1)**a)
+ sin(x)**a/(cos(x) + 1)**a
+
+ """
+
+ def f(rv):
+ if not rv.is_Mul:
+ return rv
+
+ n, d = rv.as_numer_denom()
+ if n.is_Atom or d.is_Atom:
+ return rv
+
+ def ok(k, e):
+ # initial filtering of factors
+ return (
+ (e.is_integer or k.is_positive) and (
+ k.func in (sin, cos) or (half and
+ k.is_Add and
+ len(k.args) >= 2 and
+ any(any(isinstance(ai, cos) or ai.is_Pow and ai.base is cos
+ for ai in Mul.make_args(a)) for a in k.args))))
+
+ n = n.as_powers_dict()
+ ndone = [(k, n.pop(k)) for k in list(n.keys()) if not ok(k, n[k])]
+ if not n:
+ return rv
+
+ d = d.as_powers_dict()
+ ddone = [(k, d.pop(k)) for k in list(d.keys()) if not ok(k, d[k])]
+ if not d:
+ return rv
+
+ # factoring if necessary
+
+ def factorize(d, ddone):
+ newk = []
+ for k in d:
+ if k.is_Add and len(k.args) > 1:
+ knew = factor(k) if half else factor_terms(k)
+ if knew != k:
+ newk.append((k, knew))
+ if newk:
+ for i, (k, knew) in enumerate(newk):
+ del d[k]
+ newk[i] = knew
+ newk = Mul(*newk).as_powers_dict()
+ for k in newk:
+ v = d[k] + newk[k]
+ if ok(k, v):
+ d[k] = v
+ else:
+ ddone.append((k, v))
+ del newk
+ factorize(n, ndone)
+ factorize(d, ddone)
+
+ # joining
+ t = []
+ for k in n:
+ if isinstance(k, sin):
+ a = cos(k.args[0], evaluate=False)
+ if a in d and d[a] == n[k]:
+ t.append(tan(k.args[0])**n[k])
+ n[k] = d[a] = None
+ elif half:
+ a1 = 1 + a
+ if a1 in d and d[a1] == n[k]:
+ t.append((tan(k.args[0]/2))**n[k])
+ n[k] = d[a1] = None
+ elif isinstance(k, cos):
+ a = sin(k.args[0], evaluate=False)
+ if a in d and d[a] == n[k]:
+ t.append(tan(k.args[0])**-n[k])
+ n[k] = d[a] = None
+ elif half and k.is_Add and k.args[0] is S.One and \
+ isinstance(k.args[1], cos):
+ a = sin(k.args[1].args[0], evaluate=False)
+ if a in d and d[a] == n[k] and (d[a].is_integer or \
+ a.is_positive):
+ t.append(tan(a.args[0]/2)**-n[k])
+ n[k] = d[a] = None
+
+ if t:
+ rv = Mul(*(t + [b**e for b, e in n.items() if e]))/\
+ Mul(*[b**e for b, e in d.items() if e])
+ rv *= Mul(*[b**e for b, e in ndone])/Mul(*[b**e for b, e in ddone])
+
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def TR3(rv):
+ """Induced formula: example sin(-a) = -sin(a)
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR3
+ >>> from sympy.abc import x, y
+ >>> from sympy import pi
+ >>> from sympy import cos
+ >>> TR3(cos(y - x*(y - x)))
+ cos(x*(x - y) + y)
+ >>> cos(pi/2 + x)
+ -sin(x)
+ >>> cos(30*pi/2 + x)
+ -cos(x)
+
+ """
+ from sympy.simplify.simplify import signsimp
+
+ # Negative argument (already automatic for funcs like sin(-x) -> -sin(x)
+ # but more complicated expressions can use it, too). Also, trig angles
+ # between pi/4 and pi/2 are not reduced to an angle between 0 and pi/4.
+ # The following are automatically handled:
+ # Argument of type: pi/2 +/- angle
+ # Argument of type: pi +/- angle
+ # Argument of type : 2k*pi +/- angle
+
+ def f(rv):
+ if not isinstance(rv, TrigonometricFunction):
+ return rv
+ rv = rv.func(signsimp(rv.args[0]))
+ if not isinstance(rv, TrigonometricFunction):
+ return rv
+ if (rv.args[0] - S.Pi/4).is_positive is (S.Pi/2 - rv.args[0]).is_positive is True:
+ fmap = {cos: sin, sin: cos, tan: cot, cot: tan, sec: csc, csc: sec}
+ rv = fmap[type(rv)](S.Pi/2 - rv.args[0])
+ return rv
+
+ # touch numbers iside of trig functions to let them automatically update
+ rv = rv.replace(
+ lambda x: isinstance(x, TrigonometricFunction),
+ lambda x: x.replace(
+ lambda n: n.is_number and n.is_Mul,
+ lambda n: n.func(*n.args)))
+
+ return bottom_up(rv, f)
+
+
+def TR4(rv):
+ """Identify values of special angles.
+
+ a= 0 pi/6 pi/4 pi/3 pi/2
+ ----------------------------------------------------
+ sin(a) 0 1/2 sqrt(2)/2 sqrt(3)/2 1
+ cos(a) 1 sqrt(3)/2 sqrt(2)/2 1/2 0
+ tan(a) 0 sqt(3)/3 1 sqrt(3) --
+
+ Examples
+ ========
+
+ >>> from sympy import pi
+ >>> from sympy import cos, sin, tan, cot
+ >>> for s in (0, pi/6, pi/4, pi/3, pi/2):
+ ... print('%s %s %s %s' % (cos(s), sin(s), tan(s), cot(s)))
+ ...
+ 1 0 0 zoo
+ sqrt(3)/2 1/2 sqrt(3)/3 sqrt(3)
+ sqrt(2)/2 sqrt(2)/2 1 1
+ 1/2 sqrt(3)/2 sqrt(3) sqrt(3)/3
+ 0 1 zoo 0
+ """
+ # special values at 0, pi/6, pi/4, pi/3, pi/2 already handled
+ return rv.replace(
+ lambda x:
+ isinstance(x, TrigonometricFunction) and
+ (r:=x.args[0]/pi).is_Rational and r.q in (1, 2, 3, 4, 6),
+ lambda x:
+ x.func(x.args[0].func(*x.args[0].args)))
+
+
+def _TR56(rv, f, g, h, max, pow):
+ """Helper for TR5 and TR6 to replace f**2 with h(g**2)
+
+ Options
+ =======
+
+ max : controls size of exponent that can appear on f
+ e.g. if max=4 then f**4 will be changed to h(g**2)**2.
+ pow : controls whether the exponent must be a perfect power of 2
+ e.g. if pow=True (and max >= 6) then f**6 will not be changed
+ but f**8 will be changed to h(g**2)**4
+
+ >>> from sympy.simplify.fu import _TR56 as T
+ >>> from sympy.abc import x
+ >>> from sympy import sin, cos
+ >>> h = lambda x: 1 - x
+ >>> T(sin(x)**3, sin, cos, h, 4, False)
+ (1 - cos(x)**2)*sin(x)
+ >>> T(sin(x)**6, sin, cos, h, 6, False)
+ (1 - cos(x)**2)**3
+ >>> T(sin(x)**6, sin, cos, h, 6, True)
+ sin(x)**6
+ >>> T(sin(x)**8, sin, cos, h, 10, True)
+ (1 - cos(x)**2)**4
+ """
+
+ def _f(rv):
+ # I'm not sure if this transformation should target all even powers
+ # or only those expressible as powers of 2. Also, should it only
+ # make the changes in powers that appear in sums -- making an isolated
+ # change is not going to allow a simplification as far as I can tell.
+ if not (rv.is_Pow and rv.base.func == f):
+ return rv
+ if not rv.exp.is_real:
+ return rv
+
+ if (rv.exp < 0) == True:
+ return rv
+ if (rv.exp > max) == True:
+ return rv
+ if rv.exp == 1:
+ return rv
+ if rv.exp == 2:
+ return h(g(rv.base.args[0])**2)
+ else:
+ if rv.exp % 2 == 1:
+ e = rv.exp//2
+ return f(rv.base.args[0])*h(g(rv.base.args[0])**2)**e
+ elif rv.exp == 4:
+ e = 2
+ elif not pow:
+ if rv.exp % 2:
+ return rv
+ e = rv.exp//2
+ else:
+ p = perfect_power(rv.exp)
+ if not p:
+ return rv
+ e = rv.exp//2
+ return h(g(rv.base.args[0])**2)**e
+
+ return bottom_up(rv, _f)
+
+
+def TR5(rv, max=4, pow=False):
+ """Replacement of sin**2 with 1 - cos(x)**2.
+
+ See _TR56 docstring for advanced use of ``max`` and ``pow``.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR5
+ >>> from sympy.abc import x
+ >>> from sympy import sin
+ >>> TR5(sin(x)**2)
+ 1 - cos(x)**2
+ >>> TR5(sin(x)**-2) # unchanged
+ sin(x)**(-2)
+ >>> TR5(sin(x)**4)
+ (1 - cos(x)**2)**2
+ """
+ return _TR56(rv, sin, cos, lambda x: 1 - x, max=max, pow=pow)
+
+
+def TR6(rv, max=4, pow=False):
+ """Replacement of cos**2 with 1 - sin(x)**2.
+
+ See _TR56 docstring for advanced use of ``max`` and ``pow``.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR6
+ >>> from sympy.abc import x
+ >>> from sympy import cos
+ >>> TR6(cos(x)**2)
+ 1 - sin(x)**2
+ >>> TR6(cos(x)**-2) #unchanged
+ cos(x)**(-2)
+ >>> TR6(cos(x)**4)
+ (1 - sin(x)**2)**2
+ """
+ return _TR56(rv, cos, sin, lambda x: 1 - x, max=max, pow=pow)
+
+
+def TR7(rv):
+ """Lowering the degree of cos(x)**2.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR7
+ >>> from sympy.abc import x
+ >>> from sympy import cos
+ >>> TR7(cos(x)**2)
+ cos(2*x)/2 + 1/2
+ >>> TR7(cos(x)**2 + 1)
+ cos(2*x)/2 + 3/2
+
+ """
+
+ def f(rv):
+ if not (rv.is_Pow and rv.base.func == cos and rv.exp == 2):
+ return rv
+ return (1 + cos(2*rv.base.args[0]))/2
+
+ return bottom_up(rv, f)
+
+
+def TR8(rv, first=True):
+ """Converting products of ``cos`` and/or ``sin`` to a sum or
+ difference of ``cos`` and or ``sin`` terms.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR8
+ >>> from sympy import cos, sin
+ >>> TR8(cos(2)*cos(3))
+ cos(5)/2 + cos(1)/2
+ >>> TR8(cos(2)*sin(3))
+ sin(5)/2 + sin(1)/2
+ >>> TR8(sin(2)*sin(3))
+ -cos(5)/2 + cos(1)/2
+ """
+
+ def f(rv):
+ if not (
+ rv.is_Mul or
+ rv.is_Pow and
+ rv.base.func in (cos, sin) and
+ (rv.exp.is_integer or rv.base.is_positive)):
+ return rv
+
+ if first:
+ n, d = [expand_mul(i) for i in rv.as_numer_denom()]
+ newn = TR8(n, first=False)
+ newd = TR8(d, first=False)
+ if newn != n or newd != d:
+ rv = gcd_terms(newn/newd)
+ if rv.is_Mul and rv.args[0].is_Rational and \
+ len(rv.args) == 2 and rv.args[1].is_Add:
+ rv = Mul(*rv.as_coeff_Mul())
+ return rv
+
+ args = {cos: [], sin: [], None: []}
+ for a in Mul.make_args(rv):
+ if a.func in (cos, sin):
+ args[type(a)].append(a.args[0])
+ elif (a.is_Pow and a.exp.is_Integer and a.exp > 0 and \
+ a.base.func in (cos, sin)):
+ # XXX this is ok but pathological expression could be handled
+ # more efficiently as in TRmorrie
+ args[type(a.base)].extend([a.base.args[0]]*a.exp)
+ else:
+ args[None].append(a)
+ c = args[cos]
+ s = args[sin]
+ if not (c and s or len(c) > 1 or len(s) > 1):
+ return rv
+
+ args = args[None]
+ n = min(len(c), len(s))
+ for i in range(n):
+ a1 = s.pop()
+ a2 = c.pop()
+ args.append((sin(a1 + a2) + sin(a1 - a2))/2)
+ while len(c) > 1:
+ a1 = c.pop()
+ a2 = c.pop()
+ args.append((cos(a1 + a2) + cos(a1 - a2))/2)
+ if c:
+ args.append(cos(c.pop()))
+ while len(s) > 1:
+ a1 = s.pop()
+ a2 = s.pop()
+ args.append((-cos(a1 + a2) + cos(a1 - a2))/2)
+ if s:
+ args.append(sin(s.pop()))
+ return TR8(expand_mul(Mul(*args)))
+
+ return bottom_up(rv, f)
+
+
+def TR9(rv):
+ """Sum of ``cos`` or ``sin`` terms as a product of ``cos`` or ``sin``.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR9
+ >>> from sympy import cos, sin
+ >>> TR9(cos(1) + cos(2))
+ 2*cos(1/2)*cos(3/2)
+ >>> TR9(cos(1) + 2*sin(1) + 2*sin(2))
+ cos(1) + 4*sin(3/2)*cos(1/2)
+
+ If no change is made by TR9, no re-arrangement of the
+ expression will be made. For example, though factoring
+ of common term is attempted, if the factored expression
+ was not changed, the original expression will be returned:
+
+ >>> TR9(cos(3) + cos(3)*cos(2))
+ cos(3) + cos(2)*cos(3)
+
+ """
+
+ def f(rv):
+ if not rv.is_Add:
+ return rv
+
+ def do(rv, first=True):
+ # cos(a)+/-cos(b) can be combined into a product of cosines and
+ # sin(a)+/-sin(b) can be combined into a product of cosine and
+ # sine.
+ #
+ # If there are more than two args, the pairs which "work" will
+ # have a gcd extractable and the remaining two terms will have
+ # the above structure -- all pairs must be checked to find the
+ # ones that work. args that don't have a common set of symbols
+ # are skipped since this doesn't lead to a simpler formula and
+ # also has the arbitrariness of combining, for example, the x
+ # and y term instead of the y and z term in something like
+ # cos(x) + cos(y) + cos(z).
+
+ if not rv.is_Add:
+ return rv
+
+ args = list(ordered(rv.args))
+ if len(args) != 2:
+ hit = False
+ for i in range(len(args)):
+ ai = args[i]
+ if ai is None:
+ continue
+ for j in range(i + 1, len(args)):
+ aj = args[j]
+ if aj is None:
+ continue
+ was = ai + aj
+ new = do(was)
+ if new != was:
+ args[i] = new # update in place
+ args[j] = None
+ hit = True
+ break # go to next i
+ if hit:
+ rv = Add(*[_f for _f in args if _f])
+ if rv.is_Add:
+ rv = do(rv)
+
+ return rv
+
+ # two-arg Add
+ split = trig_split(*args)
+ if not split:
+ return rv
+ gcd, n1, n2, a, b, iscos = split
+
+ # application of rule if possible
+ if iscos:
+ if n1 == n2:
+ return gcd*n1*2*cos((a + b)/2)*cos((a - b)/2)
+ if n1 < 0:
+ a, b = b, a
+ return -2*gcd*sin((a + b)/2)*sin((a - b)/2)
+ else:
+ if n1 == n2:
+ return gcd*n1*2*sin((a + b)/2)*cos((a - b)/2)
+ if n1 < 0:
+ a, b = b, a
+ return 2*gcd*cos((a + b)/2)*sin((a - b)/2)
+
+ return process_common_addends(rv, do) # DON'T sift by free symbols
+
+ return bottom_up(rv, f)
+
+
+def TR10(rv, first=True):
+ """Separate sums in ``cos`` and ``sin``.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR10
+ >>> from sympy.abc import a, b, c
+ >>> from sympy import cos, sin
+ >>> TR10(cos(a + b))
+ -sin(a)*sin(b) + cos(a)*cos(b)
+ >>> TR10(sin(a + b))
+ sin(a)*cos(b) + sin(b)*cos(a)
+ >>> TR10(sin(a + b + c))
+ (-sin(a)*sin(b) + cos(a)*cos(b))*sin(c) + \
+ (sin(a)*cos(b) + sin(b)*cos(a))*cos(c)
+ """
+
+ def f(rv):
+ if rv.func not in (cos, sin):
+ return rv
+
+ f = rv.func
+ arg = rv.args[0]
+ if arg.is_Add:
+ if first:
+ args = list(ordered(arg.args))
+ else:
+ args = list(arg.args)
+ a = args.pop()
+ b = Add._from_args(args)
+ if b.is_Add:
+ if f == sin:
+ return sin(a)*TR10(cos(b), first=False) + \
+ cos(a)*TR10(sin(b), first=False)
+ else:
+ return cos(a)*TR10(cos(b), first=False) - \
+ sin(a)*TR10(sin(b), first=False)
+ else:
+ if f == sin:
+ return sin(a)*cos(b) + cos(a)*sin(b)
+ else:
+ return cos(a)*cos(b) - sin(a)*sin(b)
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def TR10i(rv):
+ """Sum of products to function of sum.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR10i
+ >>> from sympy import cos, sin, sqrt
+ >>> from sympy.abc import x
+
+ >>> TR10i(cos(1)*cos(3) + sin(1)*sin(3))
+ cos(2)
+ >>> TR10i(cos(1)*sin(3) + sin(1)*cos(3) + cos(3))
+ cos(3) + sin(4)
+ >>> TR10i(sqrt(2)*cos(x)*x + sqrt(6)*sin(x)*x)
+ 2*sqrt(2)*x*sin(x + pi/6)
+
+ """
+ global _ROOT2, _ROOT3, _invROOT3
+ if _ROOT2 is None:
+ _roots()
+
+ def f(rv):
+ if not rv.is_Add:
+ return rv
+
+ def do(rv, first=True):
+ # args which can be expressed as A*(cos(a)*cos(b)+/-sin(a)*sin(b))
+ # or B*(cos(a)*sin(b)+/-cos(b)*sin(a)) can be combined into
+ # A*f(a+/-b) where f is either sin or cos.
+ #
+ # If there are more than two args, the pairs which "work" will have
+ # a gcd extractable and the remaining two terms will have the above
+ # structure -- all pairs must be checked to find the ones that
+ # work.
+
+ if not rv.is_Add:
+ return rv
+
+ args = list(ordered(rv.args))
+ if len(args) != 2:
+ hit = False
+ for i in range(len(args)):
+ ai = args[i]
+ if ai is None:
+ continue
+ for j in range(i + 1, len(args)):
+ aj = args[j]
+ if aj is None:
+ continue
+ was = ai + aj
+ new = do(was)
+ if new != was:
+ args[i] = new # update in place
+ args[j] = None
+ hit = True
+ break # go to next i
+ if hit:
+ rv = Add(*[_f for _f in args if _f])
+ if rv.is_Add:
+ rv = do(rv)
+
+ return rv
+
+ # two-arg Add
+ split = trig_split(*args, two=True)
+ if not split:
+ return rv
+ gcd, n1, n2, a, b, same = split
+
+ # identify and get c1 to be cos then apply rule if possible
+ if same: # coscos, sinsin
+ gcd = n1*gcd
+ if n1 == n2:
+ return gcd*cos(a - b)
+ return gcd*cos(a + b)
+ else: #cossin, cossin
+ gcd = n1*gcd
+ if n1 == n2:
+ return gcd*sin(a + b)
+ return gcd*sin(b - a)
+
+ rv = process_common_addends(
+ rv, do, lambda x: tuple(ordered(x.free_symbols)))
+
+ # need to check for inducible pairs in ratio of sqrt(3):1 that
+ # appeared in different lists when sorting by coefficient
+ while rv.is_Add:
+ byrad = defaultdict(list)
+ for a in rv.args:
+ hit = 0
+ if a.is_Mul:
+ for ai in a.args:
+ if ai.is_Pow and ai.exp is S.Half and \
+ ai.base.is_Integer:
+ byrad[ai].append(a)
+ hit = 1
+ break
+ if not hit:
+ byrad[S.One].append(a)
+
+ # no need to check all pairs -- just check for the onees
+ # that have the right ratio
+ args = []
+ for a in byrad:
+ for b in [_ROOT3*a, _invROOT3]:
+ if b in byrad:
+ for i in range(len(byrad[a])):
+ if byrad[a][i] is None:
+ continue
+ for j in range(len(byrad[b])):
+ if byrad[b][j] is None:
+ continue
+ was = Add(byrad[a][i] + byrad[b][j])
+ new = do(was)
+ if new != was:
+ args.append(new)
+ byrad[a][i] = None
+ byrad[b][j] = None
+ break
+ if args:
+ rv = Add(*(args + [Add(*[_f for _f in v if _f])
+ for v in byrad.values()]))
+ else:
+ rv = do(rv) # final pass to resolve any new inducible pairs
+ break
+
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def TR11(rv, base=None):
+ """Function of double angle to product. The ``base`` argument can be used
+ to indicate what is the un-doubled argument, e.g. if 3*pi/7 is the base
+ then cosine and sine functions with argument 6*pi/7 will be replaced.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR11
+ >>> from sympy import cos, sin, pi
+ >>> from sympy.abc import x
+ >>> TR11(sin(2*x))
+ 2*sin(x)*cos(x)
+ >>> TR11(cos(2*x))
+ -sin(x)**2 + cos(x)**2
+ >>> TR11(sin(4*x))
+ 4*(-sin(x)**2 + cos(x)**2)*sin(x)*cos(x)
+ >>> TR11(sin(4*x/3))
+ 4*(-sin(x/3)**2 + cos(x/3)**2)*sin(x/3)*cos(x/3)
+
+ If the arguments are simply integers, no change is made
+ unless a base is provided:
+
+ >>> TR11(cos(2))
+ cos(2)
+ >>> TR11(cos(4), 2)
+ -sin(2)**2 + cos(2)**2
+
+ There is a subtle issue here in that autosimplification will convert
+ some higher angles to lower angles
+
+ >>> cos(6*pi/7) + cos(3*pi/7)
+ -cos(pi/7) + cos(3*pi/7)
+
+ The 6*pi/7 angle is now pi/7 but can be targeted with TR11 by supplying
+ the 3*pi/7 base:
+
+ >>> TR11(_, 3*pi/7)
+ -sin(3*pi/7)**2 + cos(3*pi/7)**2 + cos(3*pi/7)
+
+ """
+
+ def f(rv):
+ if rv.func not in (cos, sin):
+ return rv
+
+ if base:
+ f = rv.func
+ t = f(base*2)
+ co = S.One
+ if t.is_Mul:
+ co, t = t.as_coeff_Mul()
+ if t.func not in (cos, sin):
+ return rv
+ if rv.args[0] == t.args[0]:
+ c = cos(base)
+ s = sin(base)
+ if f is cos:
+ return (c**2 - s**2)/co
+ else:
+ return 2*c*s/co
+ return rv
+
+ elif not rv.args[0].is_Number:
+ # make a change if the leading coefficient's numerator is
+ # divisible by 2
+ c, m = rv.args[0].as_coeff_Mul(rational=True)
+ if c.p % 2 == 0:
+ arg = c.p//2*m/c.q
+ c = TR11(cos(arg))
+ s = TR11(sin(arg))
+ if rv.func == sin:
+ rv = 2*s*c
+ else:
+ rv = c**2 - s**2
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def _TR11(rv):
+ """
+ Helper for TR11 to find half-arguments for sin in factors of
+ num/den that appear in cos or sin factors in the den/num.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR11, _TR11
+ >>> from sympy import cos, sin
+ >>> from sympy.abc import x
+ >>> TR11(sin(x/3)/(cos(x/6)))
+ sin(x/3)/cos(x/6)
+ >>> _TR11(sin(x/3)/(cos(x/6)))
+ 2*sin(x/6)
+ >>> TR11(sin(x/6)/(sin(x/3)))
+ sin(x/6)/sin(x/3)
+ >>> _TR11(sin(x/6)/(sin(x/3)))
+ 1/(2*cos(x/6))
+
+ """
+ def f(rv):
+ if not isinstance(rv, Expr):
+ return rv
+
+ def sincos_args(flat):
+ # find arguments of sin and cos that
+ # appears as bases in args of flat
+ # and have Integer exponents
+ args = defaultdict(set)
+ for fi in Mul.make_args(flat):
+ b, e = fi.as_base_exp()
+ if e.is_Integer and e > 0:
+ if b.func in (cos, sin):
+ args[type(b)].add(b.args[0])
+ return args
+ num_args, den_args = map(sincos_args, rv.as_numer_denom())
+ def handle_match(rv, num_args, den_args):
+ # for arg in sin args of num_args, look for arg/2
+ # in den_args and pass this half-angle to TR11
+ # for handling in rv
+ for narg in num_args[sin]:
+ half = narg/2
+ if half in den_args[cos]:
+ func = cos
+ elif half in den_args[sin]:
+ func = sin
+ else:
+ continue
+ rv = TR11(rv, half)
+ den_args[func].remove(half)
+ return rv
+ # sin in num, sin or cos in den
+ rv = handle_match(rv, num_args, den_args)
+ # sin in den, sin or cos in num
+ rv = handle_match(rv, den_args, num_args)
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def TR12(rv, first=True):
+ """Separate sums in ``tan``.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import x, y
+ >>> from sympy import tan
+ >>> from sympy.simplify.fu import TR12
+ >>> TR12(tan(x + y))
+ (tan(x) + tan(y))/(-tan(x)*tan(y) + 1)
+ """
+
+ def f(rv):
+ if not rv.func == tan:
+ return rv
+
+ arg = rv.args[0]
+ if arg.is_Add:
+ if first:
+ args = list(ordered(arg.args))
+ else:
+ args = list(arg.args)
+ a = args.pop()
+ b = Add._from_args(args)
+ if b.is_Add:
+ tb = TR12(tan(b), first=False)
+ else:
+ tb = tan(b)
+ return (tan(a) + tb)/(1 - tan(a)*tb)
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def TR12i(rv):
+ """Combine tan arguments as
+ (tan(y) + tan(x))/(tan(x)*tan(y) - 1) -> -tan(x + y).
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR12i
+ >>> from sympy import tan
+ >>> from sympy.abc import a, b, c
+ >>> ta, tb, tc = [tan(i) for i in (a, b, c)]
+ >>> TR12i((ta + tb)/(-ta*tb + 1))
+ tan(a + b)
+ >>> TR12i((ta + tb)/(ta*tb - 1))
+ -tan(a + b)
+ >>> TR12i((-ta - tb)/(ta*tb - 1))
+ tan(a + b)
+ >>> eq = (ta + tb)/(-ta*tb + 1)**2*(-3*ta - 3*tc)/(2*(ta*tc - 1))
+ >>> TR12i(eq.expand())
+ -3*tan(a + b)*tan(a + c)/(2*(tan(a) + tan(b) - 1))
+ """
+ def f(rv):
+ if not (rv.is_Add or rv.is_Mul or rv.is_Pow):
+ return rv
+
+ n, d = rv.as_numer_denom()
+ if not d.args or not n.args:
+ return rv
+
+ dok = {}
+
+ def ok(di):
+ m = as_f_sign_1(di)
+ if m:
+ g, f, s = m
+ if s is S.NegativeOne and f.is_Mul and len(f.args) == 2 and \
+ all(isinstance(fi, tan) for fi in f.args):
+ return g, f
+
+ d_args = list(Mul.make_args(d))
+ for i, di in enumerate(d_args):
+ m = ok(di)
+ if m:
+ g, t = m
+ s = Add(*[_.args[0] for _ in t.args])
+ dok[s] = S.One
+ d_args[i] = g
+ continue
+ if di.is_Add:
+ di = factor(di)
+ if di.is_Mul:
+ d_args.extend(di.args)
+ d_args[i] = S.One
+ elif di.is_Pow and (di.exp.is_integer or di.base.is_positive):
+ m = ok(di.base)
+ if m:
+ g, t = m
+ s = Add(*[_.args[0] for _ in t.args])
+ dok[s] = di.exp
+ d_args[i] = g**di.exp
+ else:
+ di = factor(di)
+ if di.is_Mul:
+ d_args.extend(di.args)
+ d_args[i] = S.One
+ if not dok:
+ return rv
+
+ def ok(ni):
+ if ni.is_Add and len(ni.args) == 2:
+ a, b = ni.args
+ if isinstance(a, tan) and isinstance(b, tan):
+ return a, b
+ n_args = list(Mul.make_args(factor_terms(n)))
+ hit = False
+ for i, ni in enumerate(n_args):
+ m = ok(ni)
+ if not m:
+ m = ok(-ni)
+ if m:
+ n_args[i] = S.NegativeOne
+ else:
+ if ni.is_Add:
+ ni = factor(ni)
+ if ni.is_Mul:
+ n_args.extend(ni.args)
+ n_args[i] = S.One
+ continue
+ elif ni.is_Pow and (
+ ni.exp.is_integer or ni.base.is_positive):
+ m = ok(ni.base)
+ if m:
+ n_args[i] = S.One
+ else:
+ ni = factor(ni)
+ if ni.is_Mul:
+ n_args.extend(ni.args)
+ n_args[i] = S.One
+ continue
+ else:
+ continue
+ else:
+ n_args[i] = S.One
+ hit = True
+ s = Add(*[_.args[0] for _ in m])
+ ed = dok[s]
+ newed = ed.extract_additively(S.One)
+ if newed is not None:
+ if newed:
+ dok[s] = newed
+ else:
+ dok.pop(s)
+ n_args[i] *= -tan(s)
+
+ if hit:
+ rv = Mul(*n_args)/Mul(*d_args)/Mul(*[(Add(*[
+ tan(a) for a in i.args]) - 1)**e for i, e in dok.items()])
+
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def TR13(rv):
+ """Change products of ``tan`` or ``cot``.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR13
+ >>> from sympy import tan, cot
+ >>> TR13(tan(3)*tan(2))
+ -tan(2)/tan(5) - tan(3)/tan(5) + 1
+ >>> TR13(cot(3)*cot(2))
+ cot(2)*cot(5) + 1 + cot(3)*cot(5)
+ """
+
+ def f(rv):
+ if not rv.is_Mul:
+ return rv
+
+ # XXX handle products of powers? or let power-reducing handle it?
+ args = {tan: [], cot: [], None: []}
+ for a in Mul.make_args(rv):
+ if a.func in (tan, cot):
+ args[type(a)].append(a.args[0])
+ else:
+ args[None].append(a)
+ t = args[tan]
+ c = args[cot]
+ if len(t) < 2 and len(c) < 2:
+ return rv
+ args = args[None]
+ while len(t) > 1:
+ t1 = t.pop()
+ t2 = t.pop()
+ args.append(1 - (tan(t1)/tan(t1 + t2) + tan(t2)/tan(t1 + t2)))
+ if t:
+ args.append(tan(t.pop()))
+ while len(c) > 1:
+ t1 = c.pop()
+ t2 = c.pop()
+ args.append(1 + cot(t1)*cot(t1 + t2) + cot(t2)*cot(t1 + t2))
+ if c:
+ args.append(cot(c.pop()))
+ return Mul(*args)
+
+ return bottom_up(rv, f)
+
+
+def TRmorrie(rv):
+ """Returns cos(x)*cos(2*x)*...*cos(2**(k-1)*x) -> sin(2**k*x)/(2**k*sin(x))
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TRmorrie, TR8, TR3
+ >>> from sympy.abc import x
+ >>> from sympy import Mul, cos, pi
+ >>> TRmorrie(cos(x)*cos(2*x))
+ sin(4*x)/(4*sin(x))
+ >>> TRmorrie(7*Mul(*[cos(x) for x in range(10)]))
+ 7*sin(12)*sin(16)*cos(5)*cos(7)*cos(9)/(64*sin(1)*sin(3))
+
+ Sometimes autosimplification will cause a power to be
+ not recognized. e.g. in the following, cos(4*pi/7) automatically
+ simplifies to -cos(3*pi/7) so only 2 of the 3 terms are
+ recognized:
+
+ >>> TRmorrie(cos(pi/7)*cos(2*pi/7)*cos(4*pi/7))
+ -sin(3*pi/7)*cos(3*pi/7)/(4*sin(pi/7))
+
+ A touch by TR8 resolves the expression to a Rational
+
+ >>> TR8(_)
+ -1/8
+
+ In this case, if eq is unsimplified, the answer is obtained
+ directly:
+
+ >>> eq = cos(pi/9)*cos(2*pi/9)*cos(3*pi/9)*cos(4*pi/9)
+ >>> TRmorrie(eq)
+ 1/16
+
+ But if angles are made canonical with TR3 then the answer
+ is not simplified without further work:
+
+ >>> TR3(eq)
+ sin(pi/18)*cos(pi/9)*cos(2*pi/9)/2
+ >>> TRmorrie(_)
+ sin(pi/18)*sin(4*pi/9)/(8*sin(pi/9))
+ >>> TR8(_)
+ cos(7*pi/18)/(16*sin(pi/9))
+ >>> TR3(_)
+ 1/16
+
+ The original expression would have resolve to 1/16 directly with TR8,
+ however:
+
+ >>> TR8(eq)
+ 1/16
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Morrie%27s_law
+
+ """
+
+ def f(rv, first=True):
+ if not rv.is_Mul:
+ return rv
+ if first:
+ n, d = rv.as_numer_denom()
+ return f(n, 0)/f(d, 0)
+
+ args = defaultdict(list)
+ coss = {}
+ other = []
+ for c in rv.args:
+ b, e = c.as_base_exp()
+ if e.is_Integer and isinstance(b, cos):
+ co, a = b.args[0].as_coeff_Mul()
+ args[a].append(co)
+ coss[b] = e
+ else:
+ other.append(c)
+
+ new = []
+ for a in args:
+ c = args[a]
+ c.sort()
+ while c:
+ k = 0
+ cc = ci = c[0]
+ while cc in c:
+ k += 1
+ cc *= 2
+ if k > 1:
+ newarg = sin(2**k*ci*a)/2**k/sin(ci*a)
+ # see how many times this can be taken
+ take = None
+ ccs = []
+ for i in range(k):
+ cc /= 2
+ key = cos(a*cc, evaluate=False)
+ ccs.append(cc)
+ take = min(coss[key], take or coss[key])
+ # update exponent counts
+ for i in range(k):
+ cc = ccs.pop()
+ key = cos(a*cc, evaluate=False)
+ coss[key] -= take
+ if not coss[key]:
+ c.remove(cc)
+ new.append(newarg**take)
+ else:
+ b = cos(c.pop(0)*a)
+ other.append(b**coss[b])
+
+ if new:
+ rv = Mul(*(new + other + [
+ cos(k*a, evaluate=False) for a in args for k in args[a]]))
+
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def TR14(rv, first=True):
+ """Convert factored powers of sin and cos identities into simpler
+ expressions.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR14
+ >>> from sympy.abc import x, y
+ >>> from sympy import cos, sin
+ >>> TR14((cos(x) - 1)*(cos(x) + 1))
+ -sin(x)**2
+ >>> TR14((sin(x) - 1)*(sin(x) + 1))
+ -cos(x)**2
+ >>> p1 = (cos(x) + 1)*(cos(x) - 1)
+ >>> p2 = (cos(y) - 1)*2*(cos(y) + 1)
+ >>> p3 = (3*(cos(y) - 1))*(3*(cos(y) + 1))
+ >>> TR14(p1*p2*p3*(x - 1))
+ -18*(x - 1)*sin(x)**2*sin(y)**4
+
+ """
+
+ def f(rv):
+ if not rv.is_Mul:
+ return rv
+
+ if first:
+ # sort them by location in numerator and denominator
+ # so the code below can just deal with positive exponents
+ n, d = rv.as_numer_denom()
+ if d is not S.One:
+ newn = TR14(n, first=False)
+ newd = TR14(d, first=False)
+ if newn != n or newd != d:
+ rv = newn/newd
+ return rv
+
+ other = []
+ process = []
+ for a in rv.args:
+ if a.is_Pow:
+ b, e = a.as_base_exp()
+ if not (e.is_integer or b.is_positive):
+ other.append(a)
+ continue
+ a = b
+ else:
+ e = S.One
+ m = as_f_sign_1(a)
+ if not m or m[1].func not in (cos, sin):
+ if e is S.One:
+ other.append(a)
+ else:
+ other.append(a**e)
+ continue
+ g, f, si = m
+ process.append((g, e.is_Number, e, f, si, a))
+
+ # sort them to get like terms next to each other
+ process = list(ordered(process))
+
+ # keep track of whether there was any change
+ nother = len(other)
+
+ # access keys
+ keys = (g, t, e, f, si, a) = list(range(6))
+
+ while process:
+ A = process.pop(0)
+ if process:
+ B = process[0]
+
+ if A[e].is_Number and B[e].is_Number:
+ # both exponents are numbers
+ if A[f] == B[f]:
+ if A[si] != B[si]:
+ B = process.pop(0)
+ take = min(A[e], B[e])
+
+ # reinsert any remainder
+ # the B will likely sort after A so check it first
+ if B[e] != take:
+ rem = [B[i] for i in keys]
+ rem[e] -= take
+ process.insert(0, rem)
+ elif A[e] != take:
+ rem = [A[i] for i in keys]
+ rem[e] -= take
+ process.insert(0, rem)
+
+ if isinstance(A[f], cos):
+ t = sin
+ else:
+ t = cos
+ other.append((-A[g]*B[g]*t(A[f].args[0])**2)**take)
+ continue
+
+ elif A[e] == B[e]:
+ # both exponents are equal symbols
+ if A[f] == B[f]:
+ if A[si] != B[si]:
+ B = process.pop(0)
+ take = A[e]
+ if isinstance(A[f], cos):
+ t = sin
+ else:
+ t = cos
+ other.append((-A[g]*B[g]*t(A[f].args[0])**2)**take)
+ continue
+
+ # either we are done or neither condition above applied
+ other.append(A[a]**A[e])
+
+ if len(other) != nother:
+ rv = Mul(*other)
+
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def TR15(rv, max=4, pow=False):
+ """Convert sin(x)**-2 to 1 + cot(x)**2.
+
+ See _TR56 docstring for advanced use of ``max`` and ``pow``.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR15
+ >>> from sympy.abc import x
+ >>> from sympy import sin
+ >>> TR15(1 - 1/sin(x)**2)
+ -cot(x)**2
+
+ """
+
+ def f(rv):
+ if not (isinstance(rv, Pow) and isinstance(rv.base, sin)):
+ return rv
+
+ e = rv.exp
+ if e % 2 == 1:
+ return TR15(rv.base**(e + 1))/rv.base
+
+ ia = 1/rv
+ a = _TR56(ia, sin, cot, lambda x: 1 + x, max=max, pow=pow)
+ if a != ia:
+ rv = a
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def TR16(rv, max=4, pow=False):
+ """Convert cos(x)**-2 to 1 + tan(x)**2.
+
+ See _TR56 docstring for advanced use of ``max`` and ``pow``.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR16
+ >>> from sympy.abc import x
+ >>> from sympy import cos
+ >>> TR16(1 - 1/cos(x)**2)
+ -tan(x)**2
+
+ """
+
+ def f(rv):
+ if not (isinstance(rv, Pow) and isinstance(rv.base, cos)):
+ return rv
+
+ e = rv.exp
+ if e % 2 == 1:
+ return TR15(rv.base**(e + 1))/rv.base
+
+ ia = 1/rv
+ a = _TR56(ia, cos, tan, lambda x: 1 + x, max=max, pow=pow)
+ if a != ia:
+ rv = a
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def TR111(rv):
+ """Convert f(x)**-i to g(x)**i where either ``i`` is an integer
+ or the base is positive and f, g are: tan, cot; sin, csc; or cos, sec.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR111
+ >>> from sympy.abc import x
+ >>> from sympy import tan
+ >>> TR111(1 - 1/tan(x)**2)
+ 1 - cot(x)**2
+
+ """
+
+ def f(rv):
+ if not (
+ isinstance(rv, Pow) and
+ (rv.base.is_positive or rv.exp.is_integer and rv.exp.is_negative)):
+ return rv
+
+ if isinstance(rv.base, tan):
+ return cot(rv.base.args[0])**-rv.exp
+ elif isinstance(rv.base, sin):
+ return csc(rv.base.args[0])**-rv.exp
+ elif isinstance(rv.base, cos):
+ return sec(rv.base.args[0])**-rv.exp
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def TR22(rv, max=4, pow=False):
+ """Convert tan(x)**2 to sec(x)**2 - 1 and cot(x)**2 to csc(x)**2 - 1.
+
+ See _TR56 docstring for advanced use of ``max`` and ``pow``.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TR22
+ >>> from sympy.abc import x
+ >>> from sympy import tan, cot
+ >>> TR22(1 + tan(x)**2)
+ sec(x)**2
+ >>> TR22(1 + cot(x)**2)
+ csc(x)**2
+
+ """
+
+ def f(rv):
+ if not (isinstance(rv, Pow) and rv.base.func in (cot, tan)):
+ return rv
+
+ rv = _TR56(rv, tan, sec, lambda x: x - 1, max=max, pow=pow)
+ rv = _TR56(rv, cot, csc, lambda x: x - 1, max=max, pow=pow)
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def TRpower(rv):
+ """Convert sin(x)**n and cos(x)**n with positive n to sums.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import TRpower
+ >>> from sympy.abc import x
+ >>> from sympy import cos, sin
+ >>> TRpower(sin(x)**6)
+ -15*cos(2*x)/32 + 3*cos(4*x)/16 - cos(6*x)/32 + 5/16
+ >>> TRpower(sin(x)**3*cos(2*x)**4)
+ (3*sin(x)/4 - sin(3*x)/4)*(cos(4*x)/2 + cos(8*x)/8 + 3/8)
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/List_of_trigonometric_identities#Power-reduction_formulae
+
+ """
+
+ def f(rv):
+ if not (isinstance(rv, Pow) and isinstance(rv.base, (sin, cos))):
+ return rv
+ b, n = rv.as_base_exp()
+ x = b.args[0]
+ if n.is_Integer and n.is_positive:
+ if n.is_odd and isinstance(b, cos):
+ rv = 2**(1-n)*Add(*[binomial(n, k)*cos((n - 2*k)*x)
+ for k in range((n + 1)/2)])
+ elif n.is_odd and isinstance(b, sin):
+ rv = 2**(1-n)*S.NegativeOne**((n-1)/2)*Add(*[binomial(n, k)*
+ S.NegativeOne**k*sin((n - 2*k)*x) for k in range((n + 1)/2)])
+ elif n.is_even and isinstance(b, cos):
+ rv = 2**(1-n)*Add(*[binomial(n, k)*cos((n - 2*k)*x)
+ for k in range(n/2)])
+ elif n.is_even and isinstance(b, sin):
+ rv = 2**(1-n)*S.NegativeOne**(n/2)*Add(*[binomial(n, k)*
+ S.NegativeOne**k*cos((n - 2*k)*x) for k in range(n/2)])
+ if n.is_even:
+ rv += 2**(-n)*binomial(n, n/2)
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def L(rv):
+ """Return count of trigonometric functions in expression.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import L
+ >>> from sympy.abc import x
+ >>> from sympy import cos, sin
+ >>> L(cos(x)+sin(x))
+ 2
+ """
+ return S(rv.count(TrigonometricFunction))
+
+
+# ============== end of basic Fu-like tools =====================
+
+if SYMPY_DEBUG:
+ (TR0, TR1, TR2, TR3, TR4, TR5, TR6, TR7, TR8, TR9, TR10, TR11, TR12, TR13,
+ TR2i, TRmorrie, TR14, TR15, TR16, TR12i, TR111, TR22
+ )= list(map(debug,
+ (TR0, TR1, TR2, TR3, TR4, TR5, TR6, TR7, TR8, TR9, TR10, TR11, TR12, TR13,
+ TR2i, TRmorrie, TR14, TR15, TR16, TR12i, TR111, TR22)))
+
+
+# tuples are chains -- (f, g) -> lambda x: g(f(x))
+# lists are choices -- [f, g] -> lambda x: min(f(x), g(x), key=objective)
+
+CTR1 = [(TR5, TR0), (TR6, TR0), identity]
+
+CTR2 = (TR11, [(TR5, TR0), (TR6, TR0), TR0])
+
+CTR3 = [(TRmorrie, TR8, TR0), (TRmorrie, TR8, TR10i, TR0), identity]
+
+CTR4 = [(TR4, TR10i), identity]
+
+RL1 = (TR4, TR3, TR4, TR12, TR4, TR13, TR4, TR0)
+
+
+# XXX it's a little unclear how this one is to be implemented
+# see Fu paper of reference, page 7. What is the Union symbol referring to?
+# The diagram shows all these as one chain of transformations, but the
+# text refers to them being applied independently. Also, a break
+# if L starts to increase has not been implemented.
+RL2 = [
+ (TR4, TR3, TR10, TR4, TR3, TR11),
+ (TR5, TR7, TR11, TR4),
+ (CTR3, CTR1, TR9, CTR2, TR4, TR9, TR9, CTR4),
+ identity,
+ ]
+
+
+def fu(rv, measure=lambda x: (L(x), x.count_ops())):
+ """Attempt to simplify expression by using transformation rules given
+ in the algorithm by Fu et al.
+
+ :func:`fu` will try to minimize the objective function ``measure``.
+ By default this first minimizes the number of trig terms and then minimizes
+ the number of total operations.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import fu
+ >>> from sympy import cos, sin, tan, pi, S, sqrt
+ >>> from sympy.abc import x, y, a, b
+
+ >>> fu(sin(50)**2 + cos(50)**2 + sin(pi/6))
+ 3/2
+ >>> fu(sqrt(6)*cos(x) + sqrt(2)*sin(x))
+ 2*sqrt(2)*sin(x + pi/3)
+
+ CTR1 example
+
+ >>> eq = sin(x)**4 - cos(y)**2 + sin(y)**2 + 2*cos(x)**2
+ >>> fu(eq)
+ cos(x)**4 - 2*cos(y)**2 + 2
+
+ CTR2 example
+
+ >>> fu(S.Half - cos(2*x)/2)
+ sin(x)**2
+
+ CTR3 example
+
+ >>> fu(sin(a)*(cos(b) - sin(b)) + cos(a)*(sin(b) + cos(b)))
+ sqrt(2)*sin(a + b + pi/4)
+
+ CTR4 example
+
+ >>> fu(sqrt(3)*cos(x)/2 + sin(x)/2)
+ sin(x + pi/3)
+
+ Example 1
+
+ >>> fu(1-sin(2*x)**2/4-sin(y)**2-cos(x)**4)
+ -cos(x)**2 + cos(y)**2
+
+ Example 2
+
+ >>> fu(cos(4*pi/9))
+ sin(pi/18)
+ >>> fu(cos(pi/9)*cos(2*pi/9)*cos(3*pi/9)*cos(4*pi/9))
+ 1/16
+
+ Example 3
+
+ >>> fu(tan(7*pi/18)+tan(5*pi/18)-sqrt(3)*tan(5*pi/18)*tan(7*pi/18))
+ -sqrt(3)
+
+ Objective function example
+
+ >>> fu(sin(x)/cos(x)) # default objective function
+ tan(x)
+ >>> fu(sin(x)/cos(x), measure=lambda x: -x.count_ops()) # maximize op count
+ sin(x)/cos(x)
+
+ References
+ ==========
+
+ .. [1] https://www.sciencedirect.com/science/article/pii/S0895717706001609
+ """
+ fRL1 = greedy(RL1, measure)
+ fRL2 = greedy(RL2, measure)
+
+ was = rv
+ rv = sympify(rv)
+ if not isinstance(rv, Expr):
+ return rv.func(*[fu(a, measure=measure) for a in rv.args])
+ rv = TR1(rv)
+ if rv.has(tan, cot):
+ rv1 = fRL1(rv)
+ if (measure(rv1) < measure(rv)):
+ rv = rv1
+ if rv.has(tan, cot):
+ rv = TR2(rv)
+ if rv.has(sin, cos):
+ rv1 = fRL2(rv)
+ rv2 = TR8(TRmorrie(rv1))
+ rv = min([was, rv, rv1, rv2], key=measure)
+ return min(TR2i(rv), rv, key=measure)
+
+
+def process_common_addends(rv, do, key2=None, key1=True):
+ """Apply ``do`` to addends of ``rv`` that (if ``key1=True``) share at least
+ a common absolute value of their coefficient and the value of ``key2`` when
+ applied to the argument. If ``key1`` is False ``key2`` must be supplied and
+ will be the only key applied.
+ """
+
+ # collect by absolute value of coefficient and key2
+ absc = defaultdict(list)
+ if key1:
+ for a in rv.args:
+ c, a = a.as_coeff_Mul()
+ if c < 0:
+ c = -c
+ a = -a # put the sign on `a`
+ absc[(c, key2(a) if key2 else 1)].append(a)
+ elif key2:
+ for a in rv.args:
+ absc[(S.One, key2(a))].append(a)
+ else:
+ raise ValueError('must have at least one key')
+
+ args = []
+ hit = False
+ for k in absc:
+ v = absc[k]
+ c, _ = k
+ if len(v) > 1:
+ e = Add(*v, evaluate=False)
+ new = do(e)
+ if new != e:
+ e = new
+ hit = True
+ args.append(c*e)
+ else:
+ args.append(c*v[0])
+ if hit:
+ rv = Add(*args)
+
+ return rv
+
+
+fufuncs = '''
+ TR0 TR1 TR2 TR3 TR4 TR5 TR6 TR7 TR8 TR9 TR10 TR10i TR11
+ TR12 TR13 L TR2i TRmorrie TR12i
+ TR14 TR15 TR16 TR111 TR22'''.split()
+FU = dict(list(zip(fufuncs, list(map(locals().get, fufuncs)))))
+
+
+def _roots():
+ global _ROOT2, _ROOT3, _invROOT3
+ _ROOT2, _ROOT3 = sqrt(2), sqrt(3)
+ _invROOT3 = 1/_ROOT3
+_ROOT2 = None
+
+
+def trig_split(a, b, two=False):
+ """Return the gcd, s1, s2, a1, a2, bool where
+
+ If two is False (default) then::
+ a + b = gcd*(s1*f(a1) + s2*f(a2)) where f = cos if bool else sin
+ else:
+ if bool, a + b was +/- cos(a1)*cos(a2) +/- sin(a1)*sin(a2) and equals
+ n1*gcd*cos(a - b) if n1 == n2 else
+ n1*gcd*cos(a + b)
+ else a + b was +/- cos(a1)*sin(a2) +/- sin(a1)*cos(a2) and equals
+ n1*gcd*sin(a + b) if n1 = n2 else
+ n1*gcd*sin(b - a)
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import trig_split
+ >>> from sympy.abc import x, y, z
+ >>> from sympy import cos, sin, sqrt
+
+ >>> trig_split(cos(x), cos(y))
+ (1, 1, 1, x, y, True)
+ >>> trig_split(2*cos(x), -2*cos(y))
+ (2, 1, -1, x, y, True)
+ >>> trig_split(cos(x)*sin(y), cos(y)*sin(y))
+ (sin(y), 1, 1, x, y, True)
+
+ >>> trig_split(cos(x), -sqrt(3)*sin(x), two=True)
+ (2, 1, -1, x, pi/6, False)
+ >>> trig_split(cos(x), sin(x), two=True)
+ (sqrt(2), 1, 1, x, pi/4, False)
+ >>> trig_split(cos(x), -sin(x), two=True)
+ (sqrt(2), 1, -1, x, pi/4, False)
+ >>> trig_split(sqrt(2)*cos(x), -sqrt(6)*sin(x), two=True)
+ (2*sqrt(2), 1, -1, x, pi/6, False)
+ >>> trig_split(-sqrt(6)*cos(x), -sqrt(2)*sin(x), two=True)
+ (-2*sqrt(2), 1, 1, x, pi/3, False)
+ >>> trig_split(cos(x)/sqrt(6), sin(x)/sqrt(2), two=True)
+ (sqrt(6)/3, 1, 1, x, pi/6, False)
+ >>> trig_split(-sqrt(6)*cos(x)*sin(y), -sqrt(2)*sin(x)*sin(y), two=True)
+ (-2*sqrt(2)*sin(y), 1, 1, x, pi/3, False)
+
+ >>> trig_split(cos(x), sin(x))
+ >>> trig_split(cos(x), sin(z))
+ >>> trig_split(2*cos(x), -sin(x))
+ >>> trig_split(cos(x), -sqrt(3)*sin(x))
+ >>> trig_split(cos(x)*cos(y), sin(x)*sin(z))
+ >>> trig_split(cos(x)*cos(y), sin(x)*sin(y))
+ >>> trig_split(-sqrt(6)*cos(x), sqrt(2)*sin(x)*sin(y), two=True)
+ """
+ global _ROOT2, _ROOT3, _invROOT3
+ if _ROOT2 is None:
+ _roots()
+
+ a, b = [Factors(i) for i in (a, b)]
+ ua, ub = a.normal(b)
+ gcd = a.gcd(b).as_expr()
+ n1 = n2 = 1
+ if S.NegativeOne in ua.factors:
+ ua = ua.quo(S.NegativeOne)
+ n1 = -n1
+ elif S.NegativeOne in ub.factors:
+ ub = ub.quo(S.NegativeOne)
+ n2 = -n2
+ a, b = [i.as_expr() for i in (ua, ub)]
+
+ def pow_cos_sin(a, two):
+ """Return ``a`` as a tuple (r, c, s) such that
+ ``a = (r or 1)*(c or 1)*(s or 1)``.
+
+ Three arguments are returned (radical, c-factor, s-factor) as
+ long as the conditions set by ``two`` are met; otherwise None is
+ returned. If ``two`` is True there will be one or two non-None
+ values in the tuple: c and s or c and r or s and r or s or c with c
+ being a cosine function (if possible) else a sine, and s being a sine
+ function (if possible) else oosine. If ``two`` is False then there
+ will only be a c or s term in the tuple.
+
+ ``two`` also require that either two cos and/or sin be present (with
+ the condition that if the functions are the same the arguments are
+ different or vice versa) or that a single cosine or a single sine
+ be present with an optional radical.
+
+ If the above conditions dictated by ``two`` are not met then None
+ is returned.
+ """
+ c = s = None
+ co = S.One
+ if a.is_Mul:
+ co, a = a.as_coeff_Mul()
+ if len(a.args) > 2 or not two:
+ return None
+ if a.is_Mul:
+ args = list(a.args)
+ else:
+ args = [a]
+ a = args.pop(0)
+ if isinstance(a, cos):
+ c = a
+ elif isinstance(a, sin):
+ s = a
+ elif a.is_Pow and a.exp is S.Half: # autoeval doesn't allow -1/2
+ co *= a
+ else:
+ return None
+ if args:
+ b = args[0]
+ if isinstance(b, cos):
+ if c:
+ s = b
+ else:
+ c = b
+ elif isinstance(b, sin):
+ if s:
+ c = b
+ else:
+ s = b
+ elif b.is_Pow and b.exp is S.Half:
+ co *= b
+ else:
+ return None
+ return co if co is not S.One else None, c, s
+ elif isinstance(a, cos):
+ c = a
+ elif isinstance(a, sin):
+ s = a
+ if c is None and s is None:
+ return
+ co = co if co is not S.One else None
+ return co, c, s
+
+ # get the parts
+ m = pow_cos_sin(a, two)
+ if m is None:
+ return
+ coa, ca, sa = m
+ m = pow_cos_sin(b, two)
+ if m is None:
+ return
+ cob, cb, sb = m
+
+ # check them
+ if (not ca) and cb or ca and isinstance(ca, sin):
+ coa, ca, sa, cob, cb, sb = cob, cb, sb, coa, ca, sa
+ n1, n2 = n2, n1
+ if not two: # need cos(x) and cos(y) or sin(x) and sin(y)
+ c = ca or sa
+ s = cb or sb
+ if not isinstance(c, s.func):
+ return None
+ return gcd, n1, n2, c.args[0], s.args[0], isinstance(c, cos)
+ else:
+ if not coa and not cob:
+ if (ca and cb and sa and sb):
+ if isinstance(ca, sa.func) is not isinstance(cb, sb.func):
+ return
+ args = {j.args for j in (ca, sa)}
+ if not all(i.args in args for i in (cb, sb)):
+ return
+ return gcd, n1, n2, ca.args[0], sa.args[0], isinstance(ca, sa.func)
+ if ca and sa or cb and sb or \
+ two and (ca is None and sa is None or cb is None and sb is None):
+ return
+ c = ca or sa
+ s = cb or sb
+ if c.args != s.args:
+ return
+ if not coa:
+ coa = S.One
+ if not cob:
+ cob = S.One
+ if coa is cob:
+ gcd *= _ROOT2
+ return gcd, n1, n2, c.args[0], pi/4, False
+ elif coa/cob == _ROOT3:
+ gcd *= 2*cob
+ return gcd, n1, n2, c.args[0], pi/3, False
+ elif coa/cob == _invROOT3:
+ gcd *= 2*coa
+ return gcd, n1, n2, c.args[0], pi/6, False
+
+
+def as_f_sign_1(e):
+ """If ``e`` is a sum that can be written as ``g*(a + s)`` where
+ ``s`` is ``+/-1``, return ``g``, ``a``, and ``s`` where ``a`` does
+ not have a leading negative coefficient.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import as_f_sign_1
+ >>> from sympy.abc import x
+ >>> as_f_sign_1(x + 1)
+ (1, x, 1)
+ >>> as_f_sign_1(x - 1)
+ (1, x, -1)
+ >>> as_f_sign_1(-x + 1)
+ (-1, x, -1)
+ >>> as_f_sign_1(-x - 1)
+ (-1, x, 1)
+ >>> as_f_sign_1(2*x + 2)
+ (2, x, 1)
+ """
+ if not e.is_Add or len(e.args) != 2:
+ return
+ # exact match
+ a, b = e.args
+ if a in (S.NegativeOne, S.One):
+ g = S.One
+ if b.is_Mul and b.args[0].is_Number and b.args[0] < 0:
+ a, b = -a, -b
+ g = -g
+ return g, b, a
+ # gcd match
+ a, b = [Factors(i) for i in e.args]
+ ua, ub = a.normal(b)
+ gcd = a.gcd(b).as_expr()
+ if S.NegativeOne in ua.factors:
+ ua = ua.quo(S.NegativeOne)
+ n1 = -1
+ n2 = 1
+ elif S.NegativeOne in ub.factors:
+ ub = ub.quo(S.NegativeOne)
+ n1 = 1
+ n2 = -1
+ else:
+ n1 = n2 = 1
+ a, b = [i.as_expr() for i in (ua, ub)]
+ if a is S.One:
+ a, b = b, a
+ n1, n2 = n2, n1
+ if n1 == -1:
+ gcd = -gcd
+ n2 = -n2
+
+ if b is S.One:
+ return gcd, a, n2
+
+
+def _osborne(e, d):
+ """Replace all hyperbolic functions with trig functions using
+ the Osborne rule.
+
+ Notes
+ =====
+
+ ``d`` is a dummy variable to prevent automatic evaluation
+ of trigonometric/hyperbolic functions.
+
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
+ """
+
+ def f(rv):
+ if not isinstance(rv, HyperbolicFunction):
+ return rv
+ a = rv.args[0]
+ a = a*d if not a.is_Add else Add._from_args([i*d for i in a.args])
+ if isinstance(rv, sinh):
+ return I*sin(a)
+ elif isinstance(rv, cosh):
+ return cos(a)
+ elif isinstance(rv, tanh):
+ return I*tan(a)
+ elif isinstance(rv, coth):
+ return cot(a)/I
+ elif isinstance(rv, sech):
+ return sec(a)
+ elif isinstance(rv, csch):
+ return csc(a)/I
+ else:
+ raise NotImplementedError('unhandled %s' % rv.func)
+
+ return bottom_up(e, f)
+
+
+def _osbornei(e, d):
+ """Replace all trig functions with hyperbolic functions using
+ the Osborne rule.
+
+ Notes
+ =====
+
+ ``d`` is a dummy variable to prevent automatic evaluation
+ of trigonometric/hyperbolic functions.
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
+ """
+
+ def f(rv):
+ if not isinstance(rv, TrigonometricFunction):
+ return rv
+ const, x = rv.args[0].as_independent(d, as_Add=True)
+ a = x.xreplace({d: S.One}) + const*I
+ if isinstance(rv, sin):
+ return sinh(a)/I
+ elif isinstance(rv, cos):
+ return cosh(a)
+ elif isinstance(rv, tan):
+ return tanh(a)/I
+ elif isinstance(rv, cot):
+ return coth(a)*I
+ elif isinstance(rv, sec):
+ return sech(a)
+ elif isinstance(rv, csc):
+ return csch(a)*I
+ else:
+ raise NotImplementedError('unhandled %s' % rv.func)
+
+ return bottom_up(e, f)
+
+
+def hyper_as_trig(rv):
+ """Return an expression containing hyperbolic functions in terms
+ of trigonometric functions. Any trigonometric functions initially
+ present are replaced with Dummy symbols and the function to undo
+ the masking and the conversion back to hyperbolics is also returned. It
+ should always be true that::
+
+ t, f = hyper_as_trig(expr)
+ expr == f(t)
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import hyper_as_trig, fu
+ >>> from sympy.abc import x
+ >>> from sympy import cosh, sinh
+ >>> eq = sinh(x)**2 + cosh(x)**2
+ >>> t, f = hyper_as_trig(eq)
+ >>> f(fu(t))
+ cosh(2*x)
+
+ References
+ ==========
+
+ .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
+ """
+ from sympy.simplify.simplify import signsimp
+ from sympy.simplify.radsimp import collect
+
+ # mask off trig functions
+ trigs = rv.atoms(TrigonometricFunction)
+ reps = [(t, Dummy()) for t in trigs]
+ masked = rv.xreplace(dict(reps))
+
+ # get inversion substitutions in place
+ reps = [(v, k) for k, v in reps]
+
+ d = Dummy()
+
+ return _osborne(masked, d), lambda x: collect(signsimp(
+ _osbornei(x, d).xreplace(dict(reps))), S.ImaginaryUnit)
+
+
+def sincos_to_sum(expr):
+ """Convert products and powers of sin and cos to sums.
+
+ Explanation
+ ===========
+
+ Applied power reduction TRpower first, then expands products, and
+ converts products to sums with TR8.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.fu import sincos_to_sum
+ >>> from sympy.abc import x
+ >>> from sympy import cos, sin
+ >>> sincos_to_sum(16*sin(x)**3*cos(2*x)**2)
+ 7*sin(x) - 5*sin(3*x) + 3*sin(5*x) - sin(7*x)
+ """
+
+ if not expr.has(cos, sin):
+ return expr
+ else:
+ return TR8(expand_mul(TRpower(expr)))
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/hyperexpand_doc.py b/janus/lib/python3.10/site-packages/sympy/simplify/hyperexpand_doc.py
new file mode 100644
index 0000000000000000000000000000000000000000..a18377f3aede5214036fbf628825536611001584
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/simplify/hyperexpand_doc.py
@@ -0,0 +1,18 @@
+""" This module cooks up a docstring when imported. Its only purpose is to
+ be displayed in the sphinx documentation. """
+
+from sympy.core.relational import Eq
+from sympy.functions.special.hyper import hyper
+from sympy.printing.latex import latex
+from sympy.simplify.hyperexpand import FormulaCollection
+
+c = FormulaCollection()
+
+doc = ""
+
+for f in c.formulae:
+ obj = Eq(hyper(f.func.ap, f.func.bq, f.z),
+ f.closed_form.rewrite('nonrepsmall'))
+ doc += ".. math::\n %s\n" % latex(obj)
+
+__doc__ = doc
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/simplify.py b/janus/lib/python3.10/site-packages/sympy/simplify/simplify.py
new file mode 100644
index 0000000000000000000000000000000000000000..af351a3c84783d25cbd97f000c070ac3360daf0f
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/simplify/simplify.py
@@ -0,0 +1,2150 @@
+from collections import defaultdict
+
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+from sympy.core import (Basic, S, Add, Mul, Pow, Symbol, sympify,
+ expand_func, Function, Dummy, Expr, factor_terms,
+ expand_power_exp, Eq)
+from sympy.core.exprtools import factor_nc
+from sympy.core.parameters import global_parameters
+from sympy.core.function import (expand_log, count_ops, _mexpand,
+ nfloat, expand_mul, expand)
+from sympy.core.numbers import Float, I, pi, Rational, equal_valued
+from sympy.core.relational import Relational
+from sympy.core.rules import Transform
+from sympy.core.sorting import ordered
+from sympy.core.sympify import _sympify
+from sympy.core.traversal import bottom_up as _bottom_up, walk as _walk
+from sympy.functions import gamma, exp, sqrt, log, exp_polar, re
+from sympy.functions.combinatorial.factorials import CombinatorialFunction
+from sympy.functions.elementary.complexes import unpolarify, Abs, sign
+from sympy.functions.elementary.exponential import ExpBase
+from sympy.functions.elementary.hyperbolic import HyperbolicFunction
+from sympy.functions.elementary.integers import ceiling
+from sympy.functions.elementary.piecewise import (Piecewise, piecewise_fold,
+ piecewise_simplify)
+from sympy.functions.elementary.trigonometric import TrigonometricFunction
+from sympy.functions.special.bessel import (BesselBase, besselj, besseli,
+ besselk, bessely, jn)
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.integrals.integrals import Integral
+from sympy.matrices.expressions import (MatrixExpr, MatAdd, MatMul,
+ MatPow, MatrixSymbol)
+from sympy.polys import together, cancel, factor
+from sympy.polys.numberfields.minpoly import _is_sum_surds, _minimal_polynomial_sq
+from sympy.simplify.combsimp import combsimp
+from sympy.simplify.cse_opts import sub_pre, sub_post
+from sympy.simplify.hyperexpand import hyperexpand
+from sympy.simplify.powsimp import powsimp
+from sympy.simplify.radsimp import radsimp, fraction, collect_abs
+from sympy.simplify.sqrtdenest import sqrtdenest
+from sympy.simplify.trigsimp import trigsimp, exptrigsimp
+from sympy.utilities.decorator import deprecated
+from sympy.utilities.iterables import has_variety, sift, subsets, iterable
+from sympy.utilities.misc import as_int
+
+import mpmath
+
+
+def separatevars(expr, symbols=[], dict=False, force=False):
+ """
+ Separates variables in an expression, if possible. By
+ default, it separates with respect to all symbols in an
+ expression and collects constant coefficients that are
+ independent of symbols.
+
+ Explanation
+ ===========
+
+ If ``dict=True`` then the separated terms will be returned
+ in a dictionary keyed to their corresponding symbols.
+ By default, all symbols in the expression will appear as
+ keys; if symbols are provided, then all those symbols will
+ be used as keys, and any terms in the expression containing
+ other symbols or non-symbols will be returned keyed to the
+ string 'coeff'. (Passing None for symbols will return the
+ expression in a dictionary keyed to 'coeff'.)
+
+ If ``force=True``, then bases of powers will be separated regardless
+ of assumptions on the symbols involved.
+
+ Notes
+ =====
+
+ The order of the factors is determined by Mul, so that the
+ separated expressions may not necessarily be grouped together.
+
+ Although factoring is necessary to separate variables in some
+ expressions, it is not necessary in all cases, so one should not
+ count on the returned factors being factored.
+
+ Examples
+ ========
+
+ >>> from sympy.abc import x, y, z, alpha
+ >>> from sympy import separatevars, sin
+ >>> separatevars((x*y)**y)
+ (x*y)**y
+ >>> separatevars((x*y)**y, force=True)
+ x**y*y**y
+
+ >>> e = 2*x**2*z*sin(y)+2*z*x**2
+ >>> separatevars(e)
+ 2*x**2*z*(sin(y) + 1)
+ >>> separatevars(e, symbols=(x, y), dict=True)
+ {'coeff': 2*z, x: x**2, y: sin(y) + 1}
+ >>> separatevars(e, [x, y, alpha], dict=True)
+ {'coeff': 2*z, alpha: 1, x: x**2, y: sin(y) + 1}
+
+ If the expression is not really separable, or is only partially
+ separable, separatevars will do the best it can to separate it
+ by using factoring.
+
+ >>> separatevars(x + x*y - 3*x**2)
+ -x*(3*x - y - 1)
+
+ If the expression is not separable then expr is returned unchanged
+ or (if dict=True) then None is returned.
+
+ >>> eq = 2*x + y*sin(x)
+ >>> separatevars(eq) == eq
+ True
+ >>> separatevars(2*x + y*sin(x), symbols=(x, y), dict=True) is None
+ True
+
+ """
+ expr = sympify(expr)
+ if dict:
+ return _separatevars_dict(_separatevars(expr, force), symbols)
+ else:
+ return _separatevars(expr, force)
+
+
+def _separatevars(expr, force):
+ if isinstance(expr, Abs):
+ arg = expr.args[0]
+ if arg.is_Mul and not arg.is_number:
+ s = separatevars(arg, dict=True, force=force)
+ if s is not None:
+ return Mul(*map(expr.func, s.values()))
+ else:
+ return expr
+
+ if len(expr.free_symbols) < 2:
+ return expr
+
+ # don't destroy a Mul since much of the work may already be done
+ if expr.is_Mul:
+ args = list(expr.args)
+ changed = False
+ for i, a in enumerate(args):
+ args[i] = separatevars(a, force)
+ changed = changed or args[i] != a
+ if changed:
+ expr = expr.func(*args)
+ return expr
+
+ # get a Pow ready for expansion
+ if expr.is_Pow and expr.base != S.Exp1:
+ expr = Pow(separatevars(expr.base, force=force), expr.exp)
+
+ # First try other expansion methods
+ expr = expr.expand(mul=False, multinomial=False, force=force)
+
+ _expr, reps = posify(expr) if force else (expr, {})
+ expr = factor(_expr).subs(reps)
+
+ if not expr.is_Add:
+ return expr
+
+ # Find any common coefficients to pull out
+ args = list(expr.args)
+ commonc = args[0].args_cnc(cset=True, warn=False)[0]
+ for i in args[1:]:
+ commonc &= i.args_cnc(cset=True, warn=False)[0]
+ commonc = Mul(*commonc)
+ commonc = commonc.as_coeff_Mul()[1] # ignore constants
+ commonc_set = commonc.args_cnc(cset=True, warn=False)[0]
+
+ # remove them
+ for i, a in enumerate(args):
+ c, nc = a.args_cnc(cset=True, warn=False)
+ c = c - commonc_set
+ args[i] = Mul(*c)*Mul(*nc)
+ nonsepar = Add(*args)
+
+ if len(nonsepar.free_symbols) > 1:
+ _expr = nonsepar
+ _expr, reps = posify(_expr) if force else (_expr, {})
+ _expr = (factor(_expr)).subs(reps)
+
+ if not _expr.is_Add:
+ nonsepar = _expr
+
+ return commonc*nonsepar
+
+
+def _separatevars_dict(expr, symbols):
+ if symbols:
+ if not all(t.is_Atom for t in symbols):
+ raise ValueError("symbols must be Atoms.")
+ symbols = list(symbols)
+ elif symbols is None:
+ return {'coeff': expr}
+ else:
+ symbols = list(expr.free_symbols)
+ if not symbols:
+ return None
+
+ ret = {i: [] for i in symbols + ['coeff']}
+
+ for i in Mul.make_args(expr):
+ expsym = i.free_symbols
+ intersection = set(symbols).intersection(expsym)
+ if len(intersection) > 1:
+ return None
+ if len(intersection) == 0:
+ # There are no symbols, so it is part of the coefficient
+ ret['coeff'].append(i)
+ else:
+ ret[intersection.pop()].append(i)
+
+ # rebuild
+ for k, v in ret.items():
+ ret[k] = Mul(*v)
+
+ return ret
+
+
+def posify(eq):
+ """Return ``eq`` (with generic symbols made positive) and a
+ dictionary containing the mapping between the old and new
+ symbols.
+
+ Explanation
+ ===========
+
+ Any symbol that has positive=None will be replaced with a positive dummy
+ symbol having the same name. This replacement will allow more symbolic
+ processing of expressions, especially those involving powers and
+ logarithms.
+
+ A dictionary that can be sent to subs to restore ``eq`` to its original
+ symbols is also returned.
+
+ >>> from sympy import posify, Symbol, log, solve
+ >>> from sympy.abc import x
+ >>> posify(x + Symbol('p', positive=True) + Symbol('n', negative=True))
+ (_x + n + p, {_x: x})
+
+ >>> eq = 1/x
+ >>> log(eq).expand()
+ log(1/x)
+ >>> log(posify(eq)[0]).expand()
+ -log(_x)
+ >>> p, rep = posify(eq)
+ >>> log(p).expand().subs(rep)
+ -log(x)
+
+ It is possible to apply the same transformations to an iterable
+ of expressions:
+
+ >>> eq = x**2 - 4
+ >>> solve(eq, x)
+ [-2, 2]
+ >>> eq_x, reps = posify([eq, x]); eq_x
+ [_x**2 - 4, _x]
+ >>> solve(*eq_x)
+ [2]
+ """
+ eq = sympify(eq)
+ if iterable(eq):
+ f = type(eq)
+ eq = list(eq)
+ syms = set()
+ for e in eq:
+ syms = syms.union(e.atoms(Symbol))
+ reps = {}
+ for s in syms:
+ reps.update({v: k for k, v in posify(s)[1].items()})
+ for i, e in enumerate(eq):
+ eq[i] = e.subs(reps)
+ return f(eq), {r: s for s, r in reps.items()}
+
+ reps = {s: Dummy(s.name, positive=True, **s.assumptions0)
+ for s in eq.free_symbols if s.is_positive is None}
+ eq = eq.subs(reps)
+ return eq, {r: s for s, r in reps.items()}
+
+
+def hypersimp(f, k):
+ """Given combinatorial term f(k) simplify its consecutive term ratio
+ i.e. f(k+1)/f(k). The input term can be composed of functions and
+ integer sequences which have equivalent representation in terms
+ of gamma special function.
+
+ Explanation
+ ===========
+
+ The algorithm performs three basic steps:
+
+ 1. Rewrite all functions in terms of gamma, if possible.
+
+ 2. Rewrite all occurrences of gamma in terms of products
+ of gamma and rising factorial with integer, absolute
+ constant exponent.
+
+ 3. Perform simplification of nested fractions, powers
+ and if the resulting expression is a quotient of
+ polynomials, reduce their total degree.
+
+ If f(k) is hypergeometric then as result we arrive with a
+ quotient of polynomials of minimal degree. Otherwise None
+ is returned.
+
+ For more information on the implemented algorithm refer to:
+
+ 1. W. Koepf, Algorithms for m-fold Hypergeometric Summation,
+ Journal of Symbolic Computation (1995) 20, 399-417
+ """
+ f = sympify(f)
+
+ g = f.subs(k, k + 1) / f
+
+ g = g.rewrite(gamma)
+ if g.has(Piecewise):
+ g = piecewise_fold(g)
+ g = g.args[-1][0]
+ g = expand_func(g)
+ g = powsimp(g, deep=True, combine='exp')
+
+ if g.is_rational_function(k):
+ return simplify(g, ratio=S.Infinity)
+ else:
+ return None
+
+
+def hypersimilar(f, g, k):
+ """
+ Returns True if ``f`` and ``g`` are hyper-similar.
+
+ Explanation
+ ===========
+
+ Similarity in hypergeometric sense means that a quotient of
+ f(k) and g(k) is a rational function in ``k``. This procedure
+ is useful in solving recurrence relations.
+
+ For more information see hypersimp().
+
+ """
+ f, g = list(map(sympify, (f, g)))
+
+ h = (f/g).rewrite(gamma)
+ h = h.expand(func=True, basic=False)
+
+ return h.is_rational_function(k)
+
+
+def signsimp(expr, evaluate=None):
+ """Make all Add sub-expressions canonical wrt sign.
+
+ Explanation
+ ===========
+
+ If an Add subexpression, ``a``, can have a sign extracted,
+ as determined by could_extract_minus_sign, it is replaced
+ with Mul(-1, a, evaluate=False). This allows signs to be
+ extracted from powers and products.
+
+ Examples
+ ========
+
+ >>> from sympy import signsimp, exp, symbols
+ >>> from sympy.abc import x, y
+ >>> i = symbols('i', odd=True)
+ >>> n = -1 + 1/x
+ >>> n/x/(-n)**2 - 1/n/x
+ (-1 + 1/x)/(x*(1 - 1/x)**2) - 1/(x*(-1 + 1/x))
+ >>> signsimp(_)
+ 0
+ >>> x*n + x*-n
+ x*(-1 + 1/x) + x*(1 - 1/x)
+ >>> signsimp(_)
+ 0
+
+ Since powers automatically handle leading signs
+
+ >>> (-2)**i
+ -2**i
+
+ signsimp can be used to put the base of a power with an integer
+ exponent into canonical form:
+
+ >>> n**i
+ (-1 + 1/x)**i
+
+ By default, signsimp does not leave behind any hollow simplification:
+ if making an Add canonical wrt sign didn't change the expression, the
+ original Add is restored. If this is not desired then the keyword
+ ``evaluate`` can be set to False:
+
+ >>> e = exp(y - x)
+ >>> signsimp(e) == e
+ True
+ >>> signsimp(e, evaluate=False)
+ exp(-(x - y))
+
+ """
+ if evaluate is None:
+ evaluate = global_parameters.evaluate
+ expr = sympify(expr)
+ if not isinstance(expr, (Expr, Relational)) or expr.is_Atom:
+ return expr
+ # get rid of an pre-existing unevaluation regarding sign
+ e = expr.replace(lambda x: x.is_Mul and -(-x) != x, lambda x: -(-x))
+ e = sub_post(sub_pre(e))
+ if not isinstance(e, (Expr, Relational)) or e.is_Atom:
+ return e
+ if e.is_Add:
+ rv = e.func(*[signsimp(a) for a in e.args])
+ if not evaluate and isinstance(rv, Add
+ ) and rv.could_extract_minus_sign():
+ return Mul(S.NegativeOne, -rv, evaluate=False)
+ return rv
+ if evaluate:
+ e = e.replace(lambda x: x.is_Mul and -(-x) != x, lambda x: -(-x))
+ return e
+
+
+def simplify(expr, ratio=1.7, measure=count_ops, rational=False, inverse=False, doit=True, **kwargs):
+ """Simplifies the given expression.
+
+ Explanation
+ ===========
+
+ Simplification is not a well defined term and the exact strategies
+ this function tries can change in the future versions of SymPy. If
+ your algorithm relies on "simplification" (whatever it is), try to
+ determine what you need exactly - is it powsimp()?, radsimp()?,
+ together()?, logcombine()?, or something else? And use this particular
+ function directly, because those are well defined and thus your algorithm
+ will be robust.
+
+ Nonetheless, especially for interactive use, or when you do not know
+ anything about the structure of the expression, simplify() tries to apply
+ intelligent heuristics to make the input expression "simpler". For
+ example:
+
+ >>> from sympy import simplify, cos, sin
+ >>> from sympy.abc import x, y
+ >>> a = (x + x**2)/(x*sin(y)**2 + x*cos(y)**2)
+ >>> a
+ (x**2 + x)/(x*sin(y)**2 + x*cos(y)**2)
+ >>> simplify(a)
+ x + 1
+
+ Note that we could have obtained the same result by using specific
+ simplification functions:
+
+ >>> from sympy import trigsimp, cancel
+ >>> trigsimp(a)
+ (x**2 + x)/x
+ >>> cancel(_)
+ x + 1
+
+ In some cases, applying :func:`simplify` may actually result in some more
+ complicated expression. The default ``ratio=1.7`` prevents more extreme
+ cases: if (result length)/(input length) > ratio, then input is returned
+ unmodified. The ``measure`` parameter lets you specify the function used
+ to determine how complex an expression is. The function should take a
+ single argument as an expression and return a number such that if
+ expression ``a`` is more complex than expression ``b``, then
+ ``measure(a) > measure(b)``. The default measure function is
+ :func:`~.count_ops`, which returns the total number of operations in the
+ expression.
+
+ For example, if ``ratio=1``, ``simplify`` output cannot be longer
+ than input.
+
+ ::
+
+ >>> from sympy import sqrt, simplify, count_ops, oo
+ >>> root = 1/(sqrt(2)+3)
+
+ Since ``simplify(root)`` would result in a slightly longer expression,
+ root is returned unchanged instead::
+
+ >>> simplify(root, ratio=1) == root
+ True
+
+ If ``ratio=oo``, simplify will be applied anyway::
+
+ >>> count_ops(simplify(root, ratio=oo)) > count_ops(root)
+ True
+
+ Note that the shortest expression is not necessary the simplest, so
+ setting ``ratio`` to 1 may not be a good idea.
+ Heuristically, the default value ``ratio=1.7`` seems like a reasonable
+ choice.
+
+ You can easily define your own measure function based on what you feel
+ should represent the "size" or "complexity" of the input expression. Note
+ that some choices, such as ``lambda expr: len(str(expr))`` may appear to be
+ good metrics, but have other problems (in this case, the measure function
+ may slow down simplify too much for very large expressions). If you do not
+ know what a good metric would be, the default, ``count_ops``, is a good
+ one.
+
+ For example:
+
+ >>> from sympy import symbols, log
+ >>> a, b = symbols('a b', positive=True)
+ >>> g = log(a) + log(b) + log(a)*log(1/b)
+ >>> h = simplify(g)
+ >>> h
+ log(a*b**(1 - log(a)))
+ >>> count_ops(g)
+ 8
+ >>> count_ops(h)
+ 5
+
+ So you can see that ``h`` is simpler than ``g`` using the count_ops metric.
+ However, we may not like how ``simplify`` (in this case, using
+ ``logcombine``) has created the ``b**(log(1/a) + 1)`` term. A simple way
+ to reduce this would be to give more weight to powers as operations in
+ ``count_ops``. We can do this by using the ``visual=True`` option:
+
+ >>> print(count_ops(g, visual=True))
+ 2*ADD + DIV + 4*LOG + MUL
+ >>> print(count_ops(h, visual=True))
+ 2*LOG + MUL + POW + SUB
+
+ >>> from sympy import Symbol, S
+ >>> def my_measure(expr):
+ ... POW = Symbol('POW')
+ ... # Discourage powers by giving POW a weight of 10
+ ... count = count_ops(expr, visual=True).subs(POW, 10)
+ ... # Every other operation gets a weight of 1 (the default)
+ ... count = count.replace(Symbol, type(S.One))
+ ... return count
+ >>> my_measure(g)
+ 8
+ >>> my_measure(h)
+ 14
+ >>> 15./8 > 1.7 # 1.7 is the default ratio
+ True
+ >>> simplify(g, measure=my_measure)
+ -log(a)*log(b) + log(a) + log(b)
+
+ Note that because ``simplify()`` internally tries many different
+ simplification strategies and then compares them using the measure
+ function, we get a completely different result that is still different
+ from the input expression by doing this.
+
+ If ``rational=True``, Floats will be recast as Rationals before simplification.
+ If ``rational=None``, Floats will be recast as Rationals but the result will
+ be recast as Floats. If rational=False(default) then nothing will be done
+ to the Floats.
+
+ If ``inverse=True``, it will be assumed that a composition of inverse
+ functions, such as sin and asin, can be cancelled in any order.
+ For example, ``asin(sin(x))`` will yield ``x`` without checking whether
+ x belongs to the set where this relation is true. The default is
+ False.
+
+ Note that ``simplify()`` automatically calls ``doit()`` on the final
+ expression. You can avoid this behavior by passing ``doit=False`` as
+ an argument.
+
+ Also, it should be noted that simplifying a boolean expression is not
+ well defined. If the expression prefers automatic evaluation (such as
+ :obj:`~.Eq()` or :obj:`~.Or()`), simplification will return ``True`` or
+ ``False`` if truth value can be determined. If the expression is not
+ evaluated by default (such as :obj:`~.Predicate()`), simplification will
+ not reduce it and you should use :func:`~.refine()` or :func:`~.ask()`
+ function. This inconsistency will be resolved in future version.
+
+ See Also
+ ========
+
+ sympy.assumptions.refine.refine : Simplification using assumptions.
+ sympy.assumptions.ask.ask : Query for boolean expressions using assumptions.
+ """
+
+ def shorter(*choices):
+ """
+ Return the choice that has the fewest ops. In case of a tie,
+ the expression listed first is selected.
+ """
+ if not has_variety(choices):
+ return choices[0]
+ return min(choices, key=measure)
+
+ def done(e):
+ rv = e.doit() if doit else e
+ return shorter(rv, collect_abs(rv))
+
+ expr = sympify(expr, rational=rational)
+ kwargs = {
+ "ratio": kwargs.get('ratio', ratio),
+ "measure": kwargs.get('measure', measure),
+ "rational": kwargs.get('rational', rational),
+ "inverse": kwargs.get('inverse', inverse),
+ "doit": kwargs.get('doit', doit)}
+ # no routine for Expr needs to check for is_zero
+ if isinstance(expr, Expr) and expr.is_zero:
+ return S.Zero if not expr.is_Number else expr
+
+ _eval_simplify = getattr(expr, '_eval_simplify', None)
+ if _eval_simplify is not None:
+ return _eval_simplify(**kwargs)
+
+ original_expr = expr = collect_abs(signsimp(expr))
+
+ if not isinstance(expr, Basic) or not expr.args: # XXX: temporary hack
+ return expr
+
+ if inverse and expr.has(Function):
+ expr = inversecombine(expr)
+ if not expr.args: # simplified to atomic
+ return expr
+
+ # do deep simplification
+ handled = Add, Mul, Pow, ExpBase
+ expr = expr.replace(
+ # here, checking for x.args is not enough because Basic has
+ # args but Basic does not always play well with replace, e.g.
+ # when simultaneous is True found expressions will be masked
+ # off with a Dummy but not all Basic objects in an expression
+ # can be replaced with a Dummy
+ lambda x: isinstance(x, Expr) and x.args and not isinstance(
+ x, handled),
+ lambda x: x.func(*[simplify(i, **kwargs) for i in x.args]),
+ simultaneous=False)
+ if not isinstance(expr, handled):
+ return done(expr)
+
+ if not expr.is_commutative:
+ expr = nc_simplify(expr)
+
+ # TODO: Apply different strategies, considering expression pattern:
+ # is it a purely rational function? Is there any trigonometric function?...
+ # See also https://github.com/sympy/sympy/pull/185.
+
+
+ # rationalize Floats
+ floats = False
+ if rational is not False and expr.has(Float):
+ floats = True
+ expr = nsimplify(expr, rational=True)
+
+ expr = _bottom_up(expr, lambda w: getattr(w, 'normal', lambda: w)())
+ expr = Mul(*powsimp(expr).as_content_primitive())
+ _e = cancel(expr)
+ expr1 = shorter(_e, _mexpand(_e).cancel()) # issue 6829
+ expr2 = shorter(together(expr, deep=True), together(expr1, deep=True))
+
+ if ratio is S.Infinity:
+ expr = expr2
+ else:
+ expr = shorter(expr2, expr1, expr)
+ if not isinstance(expr, Basic): # XXX: temporary hack
+ return expr
+
+ expr = factor_terms(expr, sign=False)
+
+ # must come before `Piecewise` since this introduces more `Piecewise` terms
+ if expr.has(sign):
+ expr = expr.rewrite(Abs)
+
+ # Deal with Piecewise separately to avoid recursive growth of expressions
+ if expr.has(Piecewise):
+ # Fold into a single Piecewise
+ expr = piecewise_fold(expr)
+ # Apply doit, if doit=True
+ expr = done(expr)
+ # Still a Piecewise?
+ if expr.has(Piecewise):
+ # Fold into a single Piecewise, in case doit lead to some
+ # expressions being Piecewise
+ expr = piecewise_fold(expr)
+ # kroneckersimp also affects Piecewise
+ if expr.has(KroneckerDelta):
+ expr = kroneckersimp(expr)
+ # Still a Piecewise?
+ if expr.has(Piecewise):
+ # Do not apply doit on the segments as it has already
+ # been done above, but simplify
+ expr = piecewise_simplify(expr, deep=True, doit=False)
+ # Still a Piecewise?
+ if expr.has(Piecewise):
+ # Try factor common terms
+ expr = shorter(expr, factor_terms(expr))
+ # As all expressions have been simplified above with the
+ # complete simplify, nothing more needs to be done here
+ return expr
+
+ # hyperexpand automatically only works on hypergeometric terms
+ # Do this after the Piecewise part to avoid recursive expansion
+ expr = hyperexpand(expr)
+
+ if expr.has(KroneckerDelta):
+ expr = kroneckersimp(expr)
+
+ if expr.has(BesselBase):
+ expr = besselsimp(expr)
+
+ if expr.has(TrigonometricFunction, HyperbolicFunction):
+ expr = trigsimp(expr, deep=True)
+
+ if expr.has(log):
+ expr = shorter(expand_log(expr, deep=True), logcombine(expr))
+
+ if expr.has(CombinatorialFunction, gamma):
+ # expression with gamma functions or non-integer arguments is
+ # automatically passed to gammasimp
+ expr = combsimp(expr)
+
+ if expr.has(Sum):
+ expr = sum_simplify(expr, **kwargs)
+
+ if expr.has(Integral):
+ expr = expr.xreplace({
+ i: factor_terms(i) for i in expr.atoms(Integral)})
+
+ if expr.has(Product):
+ expr = product_simplify(expr, **kwargs)
+
+ from sympy.physics.units import Quantity
+
+ if expr.has(Quantity):
+ from sympy.physics.units.util import quantity_simplify
+ expr = quantity_simplify(expr)
+
+ short = shorter(powsimp(expr, combine='exp', deep=True), powsimp(expr), expr)
+ short = shorter(short, cancel(short))
+ short = shorter(short, factor_terms(short), expand_power_exp(expand_mul(short)))
+ if short.has(TrigonometricFunction, HyperbolicFunction, ExpBase, exp):
+ short = exptrigsimp(short)
+
+ # get rid of hollow 2-arg Mul factorization
+ hollow_mul = Transform(
+ lambda x: Mul(*x.args),
+ lambda x:
+ x.is_Mul and
+ len(x.args) == 2 and
+ x.args[0].is_Number and
+ x.args[1].is_Add and
+ x.is_commutative)
+ expr = short.xreplace(hollow_mul)
+
+ numer, denom = expr.as_numer_denom()
+ if denom.is_Add:
+ n, d = fraction(radsimp(1/denom, symbolic=False, max_terms=1))
+ if n is not S.One:
+ expr = (numer*n).expand()/d
+
+ if expr.could_extract_minus_sign():
+ n, d = fraction(expr)
+ if d != 0:
+ expr = signsimp(-n/(-d))
+
+ if measure(expr) > ratio*measure(original_expr):
+ expr = original_expr
+
+ # restore floats
+ if floats and rational is None:
+ expr = nfloat(expr, exponent=False)
+
+ return done(expr)
+
+
+def sum_simplify(s, **kwargs):
+ """Main function for Sum simplification"""
+ if not isinstance(s, Add):
+ s = s.xreplace({a: sum_simplify(a, **kwargs)
+ for a in s.atoms(Add) if a.has(Sum)})
+ s = expand(s)
+ if not isinstance(s, Add):
+ return s
+
+ terms = s.args
+ s_t = [] # Sum Terms
+ o_t = [] # Other Terms
+
+ for term in terms:
+ sum_terms, other = sift(Mul.make_args(term),
+ lambda i: isinstance(i, Sum), binary=True)
+ if not sum_terms:
+ o_t.append(term)
+ continue
+ other = [Mul(*other)]
+ s_t.append(Mul(*(other + [s._eval_simplify(**kwargs) for s in sum_terms])))
+
+ result = Add(sum_combine(s_t), *o_t)
+
+ return result
+
+
+def sum_combine(s_t):
+ """Helper function for Sum simplification
+
+ Attempts to simplify a list of sums, by combining limits / sum function's
+ returns the simplified sum
+ """
+ used = [False] * len(s_t)
+
+ for method in range(2):
+ for i, s_term1 in enumerate(s_t):
+ if not used[i]:
+ for j, s_term2 in enumerate(s_t):
+ if not used[j] and i != j:
+ temp = sum_add(s_term1, s_term2, method)
+ if isinstance(temp, (Sum, Mul)):
+ s_t[i] = temp
+ s_term1 = s_t[i]
+ used[j] = True
+
+ result = S.Zero
+ for i, s_term in enumerate(s_t):
+ if not used[i]:
+ result = Add(result, s_term)
+
+ return result
+
+
+def factor_sum(self, limits=None, radical=False, clear=False, fraction=False, sign=True):
+ """Return Sum with constant factors extracted.
+
+ If ``limits`` is specified then ``self`` is the summand; the other
+ keywords are passed to ``factor_terms``.
+
+ Examples
+ ========
+
+ >>> from sympy import Sum
+ >>> from sympy.abc import x, y
+ >>> from sympy.simplify.simplify import factor_sum
+ >>> s = Sum(x*y, (x, 1, 3))
+ >>> factor_sum(s)
+ y*Sum(x, (x, 1, 3))
+ >>> factor_sum(s.function, s.limits)
+ y*Sum(x, (x, 1, 3))
+ """
+ # XXX deprecate in favor of direct call to factor_terms
+ kwargs = {"radical": radical, "clear": clear,
+ "fraction": fraction, "sign": sign}
+ expr = Sum(self, *limits) if limits else self
+ return factor_terms(expr, **kwargs)
+
+
+def sum_add(self, other, method=0):
+ """Helper function for Sum simplification"""
+ #we know this is something in terms of a constant * a sum
+ #so we temporarily put the constants inside for simplification
+ #then simplify the result
+ def __refactor(val):
+ args = Mul.make_args(val)
+ sumv = next(x for x in args if isinstance(x, Sum))
+ constant = Mul(*[x for x in args if x != sumv])
+ return Sum(constant * sumv.function, *sumv.limits)
+
+ if isinstance(self, Mul):
+ rself = __refactor(self)
+ else:
+ rself = self
+
+ if isinstance(other, Mul):
+ rother = __refactor(other)
+ else:
+ rother = other
+
+ if type(rself) is type(rother):
+ if method == 0:
+ if rself.limits == rother.limits:
+ return factor_sum(Sum(rself.function + rother.function, *rself.limits))
+ elif method == 1:
+ if simplify(rself.function - rother.function) == 0:
+ if len(rself.limits) == len(rother.limits) == 1:
+ i = rself.limits[0][0]
+ x1 = rself.limits[0][1]
+ y1 = rself.limits[0][2]
+ j = rother.limits[0][0]
+ x2 = rother.limits[0][1]
+ y2 = rother.limits[0][2]
+
+ if i == j:
+ if x2 == y1 + 1:
+ return factor_sum(Sum(rself.function, (i, x1, y2)))
+ elif x1 == y2 + 1:
+ return factor_sum(Sum(rself.function, (i, x2, y1)))
+
+ return Add(self, other)
+
+
+def product_simplify(s, **kwargs):
+ """Main function for Product simplification"""
+ terms = Mul.make_args(s)
+ p_t = [] # Product Terms
+ o_t = [] # Other Terms
+
+ deep = kwargs.get('deep', True)
+ for term in terms:
+ if isinstance(term, Product):
+ if deep:
+ p_t.append(Product(term.function.simplify(**kwargs),
+ *term.limits))
+ else:
+ p_t.append(term)
+ else:
+ o_t.append(term)
+
+ used = [False] * len(p_t)
+
+ for method in range(2):
+ for i, p_term1 in enumerate(p_t):
+ if not used[i]:
+ for j, p_term2 in enumerate(p_t):
+ if not used[j] and i != j:
+ tmp_prod = product_mul(p_term1, p_term2, method)
+ if isinstance(tmp_prod, Product):
+ p_t[i] = tmp_prod
+ used[j] = True
+
+ result = Mul(*o_t)
+
+ for i, p_term in enumerate(p_t):
+ if not used[i]:
+ result = Mul(result, p_term)
+
+ return result
+
+
+def product_mul(self, other, method=0):
+ """Helper function for Product simplification"""
+ if type(self) is type(other):
+ if method == 0:
+ if self.limits == other.limits:
+ return Product(self.function * other.function, *self.limits)
+ elif method == 1:
+ if simplify(self.function - other.function) == 0:
+ if len(self.limits) == len(other.limits) == 1:
+ i = self.limits[0][0]
+ x1 = self.limits[0][1]
+ y1 = self.limits[0][2]
+ j = other.limits[0][0]
+ x2 = other.limits[0][1]
+ y2 = other.limits[0][2]
+
+ if i == j:
+ if x2 == y1 + 1:
+ return Product(self.function, (i, x1, y2))
+ elif x1 == y2 + 1:
+ return Product(self.function, (i, x2, y1))
+
+ return Mul(self, other)
+
+
+def _nthroot_solve(p, n, prec):
+ """
+ helper function for ``nthroot``
+ It denests ``p**Rational(1, n)`` using its minimal polynomial
+ """
+ from sympy.solvers import solve
+ while n % 2 == 0:
+ p = sqrtdenest(sqrt(p))
+ n = n // 2
+ if n == 1:
+ return p
+ pn = p**Rational(1, n)
+ x = Symbol('x')
+ f = _minimal_polynomial_sq(p, n, x)
+ if f is None:
+ return None
+ sols = solve(f, x)
+ for sol in sols:
+ if abs(sol - pn).n() < 1./10**prec:
+ sol = sqrtdenest(sol)
+ if _mexpand(sol**n) == p:
+ return sol
+
+
+def logcombine(expr, force=False):
+ """
+ Takes logarithms and combines them using the following rules:
+
+ - log(x) + log(y) == log(x*y) if both are positive
+ - a*log(x) == log(x**a) if x is positive and a is real
+
+ If ``force`` is ``True`` then the assumptions above will be assumed to hold if
+ there is no assumption already in place on a quantity. For example, if
+ ``a`` is imaginary or the argument negative, force will not perform a
+ combination but if ``a`` is a symbol with no assumptions the change will
+ take place.
+
+ Examples
+ ========
+
+ >>> from sympy import Symbol, symbols, log, logcombine, I
+ >>> from sympy.abc import a, x, y, z
+ >>> logcombine(a*log(x) + log(y) - log(z))
+ a*log(x) + log(y) - log(z)
+ >>> logcombine(a*log(x) + log(y) - log(z), force=True)
+ log(x**a*y/z)
+ >>> x,y,z = symbols('x,y,z', positive=True)
+ >>> a = Symbol('a', real=True)
+ >>> logcombine(a*log(x) + log(y) - log(z))
+ log(x**a*y/z)
+
+ The transformation is limited to factors and/or terms that
+ contain logs, so the result depends on the initial state of
+ expansion:
+
+ >>> eq = (2 + 3*I)*log(x)
+ >>> logcombine(eq, force=True) == eq
+ True
+ >>> logcombine(eq.expand(), force=True)
+ log(x**2) + I*log(x**3)
+
+ See Also
+ ========
+
+ posify: replace all symbols with symbols having positive assumptions
+ sympy.core.function.expand_log: expand the logarithms of products
+ and powers; the opposite of logcombine
+
+ """
+
+ def f(rv):
+ if not (rv.is_Add or rv.is_Mul):
+ return rv
+
+ def gooda(a):
+ # bool to tell whether the leading ``a`` in ``a*log(x)``
+ # could appear as log(x**a)
+ return (a is not S.NegativeOne and # -1 *could* go, but we disallow
+ (a.is_extended_real or force and a.is_extended_real is not False))
+
+ def goodlog(l):
+ # bool to tell whether log ``l``'s argument can combine with others
+ a = l.args[0]
+ return a.is_positive or force and a.is_nonpositive is not False
+
+ other = []
+ logs = []
+ log1 = defaultdict(list)
+ for a in Add.make_args(rv):
+ if isinstance(a, log) and goodlog(a):
+ log1[()].append(([], a))
+ elif not a.is_Mul:
+ other.append(a)
+ else:
+ ot = []
+ co = []
+ lo = []
+ for ai in a.args:
+ if ai.is_Rational and ai < 0:
+ ot.append(S.NegativeOne)
+ co.append(-ai)
+ elif isinstance(ai, log) and goodlog(ai):
+ lo.append(ai)
+ elif gooda(ai):
+ co.append(ai)
+ else:
+ ot.append(ai)
+ if len(lo) > 1:
+ logs.append((ot, co, lo))
+ elif lo:
+ log1[tuple(ot)].append((co, lo[0]))
+ else:
+ other.append(a)
+
+ # if there is only one log in other, put it with the
+ # good logs
+ if len(other) == 1 and isinstance(other[0], log):
+ log1[()].append(([], other.pop()))
+ # if there is only one log at each coefficient and none have
+ # an exponent to place inside the log then there is nothing to do
+ if not logs and all(len(log1[k]) == 1 and log1[k][0] == [] for k in log1):
+ return rv
+
+ # collapse multi-logs as far as possible in a canonical way
+ # TODO: see if x*log(a)+x*log(a)*log(b) -> x*log(a)*(1+log(b))?
+ # -- in this case, it's unambiguous, but if it were were a log(c) in
+ # each term then it's arbitrary whether they are grouped by log(a) or
+ # by log(c). So for now, just leave this alone; it's probably better to
+ # let the user decide
+ for o, e, l in logs:
+ l = list(ordered(l))
+ e = log(l.pop(0).args[0]**Mul(*e))
+ while l:
+ li = l.pop(0)
+ e = log(li.args[0]**e)
+ c, l = Mul(*o), e
+ if isinstance(l, log): # it should be, but check to be sure
+ log1[(c,)].append(([], l))
+ else:
+ other.append(c*l)
+
+ # logs that have the same coefficient can multiply
+ for k in list(log1.keys()):
+ log1[Mul(*k)] = log(logcombine(Mul(*[
+ l.args[0]**Mul(*c) for c, l in log1.pop(k)]),
+ force=force), evaluate=False)
+
+ # logs that have oppositely signed coefficients can divide
+ for k in ordered(list(log1.keys())):
+ if k not in log1: # already popped as -k
+ continue
+ if -k in log1:
+ # figure out which has the minus sign; the one with
+ # more op counts should be the one
+ num, den = k, -k
+ if num.count_ops() > den.count_ops():
+ num, den = den, num
+ other.append(
+ num*log(log1.pop(num).args[0]/log1.pop(den).args[0],
+ evaluate=False))
+ else:
+ other.append(k*log1.pop(k))
+
+ return Add(*other)
+
+ return _bottom_up(expr, f)
+
+
+def inversecombine(expr):
+ """Simplify the composition of a function and its inverse.
+
+ Explanation
+ ===========
+
+ No attention is paid to whether the inverse is a left inverse or a
+ right inverse; thus, the result will in general not be equivalent
+ to the original expression.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.simplify import inversecombine
+ >>> from sympy import asin, sin, log, exp
+ >>> from sympy.abc import x
+ >>> inversecombine(asin(sin(x)))
+ x
+ >>> inversecombine(2*log(exp(3*x)))
+ 6*x
+ """
+
+ def f(rv):
+ if isinstance(rv, log):
+ if isinstance(rv.args[0], exp) or (rv.args[0].is_Pow and rv.args[0].base == S.Exp1):
+ rv = rv.args[0].exp
+ elif rv.is_Function and hasattr(rv, "inverse"):
+ if (len(rv.args) == 1 and len(rv.args[0].args) == 1 and
+ isinstance(rv.args[0], rv.inverse(argindex=1))):
+ rv = rv.args[0].args[0]
+ if rv.is_Pow and rv.base == S.Exp1:
+ if isinstance(rv.exp, log):
+ rv = rv.exp.args[0]
+ return rv
+
+ return _bottom_up(expr, f)
+
+
+def kroneckersimp(expr):
+ """
+ Simplify expressions with KroneckerDelta.
+
+ The only simplification currently attempted is to identify multiplicative cancellation:
+
+ Examples
+ ========
+
+ >>> from sympy import KroneckerDelta, kroneckersimp
+ >>> from sympy.abc import i
+ >>> kroneckersimp(1 + KroneckerDelta(0, i) * KroneckerDelta(1, i))
+ 1
+ """
+ def args_cancel(args1, args2):
+ for i1 in range(2):
+ for i2 in range(2):
+ a1 = args1[i1]
+ a2 = args2[i2]
+ a3 = args1[(i1 + 1) % 2]
+ a4 = args2[(i2 + 1) % 2]
+ if Eq(a1, a2) is S.true and Eq(a3, a4) is S.false:
+ return True
+ return False
+
+ def cancel_kronecker_mul(m):
+ args = m.args
+ deltas = [a for a in args if isinstance(a, KroneckerDelta)]
+ for delta1, delta2 in subsets(deltas, 2):
+ args1 = delta1.args
+ args2 = delta2.args
+ if args_cancel(args1, args2):
+ return S.Zero * m # In case of oo etc
+ return m
+
+ if not expr.has(KroneckerDelta):
+ return expr
+
+ if expr.has(Piecewise):
+ expr = expr.rewrite(KroneckerDelta)
+
+ newexpr = expr
+ expr = None
+
+ while newexpr != expr:
+ expr = newexpr
+ newexpr = expr.replace(lambda e: isinstance(e, Mul), cancel_kronecker_mul)
+
+ return expr
+
+
+def besselsimp(expr):
+ """
+ Simplify bessel-type functions.
+
+ Explanation
+ ===========
+
+ This routine tries to simplify bessel-type functions. Currently it only
+ works on the Bessel J and I functions, however. It works by looking at all
+ such functions in turn, and eliminating factors of "I" and "-1" (actually
+ their polar equivalents) in front of the argument. Then, functions of
+ half-integer order are rewritten using trigonometric functions and
+ functions of integer order (> 1) are rewritten using functions
+ of low order. Finally, if the expression was changed, compute
+ factorization of the result with factor().
+
+ >>> from sympy import besselj, besseli, besselsimp, polar_lift, I, S
+ >>> from sympy.abc import z, nu
+ >>> besselsimp(besselj(nu, z*polar_lift(-1)))
+ exp(I*pi*nu)*besselj(nu, z)
+ >>> besselsimp(besseli(nu, z*polar_lift(-I)))
+ exp(-I*pi*nu/2)*besselj(nu, z)
+ >>> besselsimp(besseli(S(-1)/2, z))
+ sqrt(2)*cosh(z)/(sqrt(pi)*sqrt(z))
+ >>> besselsimp(z*besseli(0, z) + z*(besseli(2, z))/2 + besseli(1, z))
+ 3*z*besseli(0, z)/2
+ """
+ # TODO
+ # - better algorithm?
+ # - simplify (cos(pi*b)*besselj(b,z) - besselj(-b,z))/sin(pi*b) ...
+ # - use contiguity relations?
+
+ def replacer(fro, to, factors):
+ factors = set(factors)
+
+ def repl(nu, z):
+ if factors.intersection(Mul.make_args(z)):
+ return to(nu, z)
+ return fro(nu, z)
+ return repl
+
+ def torewrite(fro, to):
+ def tofunc(nu, z):
+ return fro(nu, z).rewrite(to)
+ return tofunc
+
+ def tominus(fro):
+ def tofunc(nu, z):
+ return exp(I*pi*nu)*fro(nu, exp_polar(-I*pi)*z)
+ return tofunc
+
+ orig_expr = expr
+
+ ifactors = [I, exp_polar(I*pi/2), exp_polar(-I*pi/2)]
+ expr = expr.replace(
+ besselj, replacer(besselj,
+ torewrite(besselj, besseli), ifactors))
+ expr = expr.replace(
+ besseli, replacer(besseli,
+ torewrite(besseli, besselj), ifactors))
+
+ minusfactors = [-1, exp_polar(I*pi)]
+ expr = expr.replace(
+ besselj, replacer(besselj, tominus(besselj), minusfactors))
+ expr = expr.replace(
+ besseli, replacer(besseli, tominus(besseli), minusfactors))
+
+ z0 = Dummy('z')
+
+ def expander(fro):
+ def repl(nu, z):
+ if (nu % 1) == S.Half:
+ return simplify(trigsimp(unpolarify(
+ fro(nu, z0).rewrite(besselj).rewrite(jn).expand(
+ func=True)).subs(z0, z)))
+ elif nu.is_Integer and nu > 1:
+ return fro(nu, z).expand(func=True)
+ return fro(nu, z)
+ return repl
+
+ expr = expr.replace(besselj, expander(besselj))
+ expr = expr.replace(bessely, expander(bessely))
+ expr = expr.replace(besseli, expander(besseli))
+ expr = expr.replace(besselk, expander(besselk))
+
+ def _bessel_simp_recursion(expr):
+
+ def _use_recursion(bessel, expr):
+ while True:
+ bessels = expr.find(lambda x: isinstance(x, bessel))
+ try:
+ for ba in sorted(bessels, key=lambda x: re(x.args[0])):
+ a, x = ba.args
+ bap1 = bessel(a+1, x)
+ bap2 = bessel(a+2, x)
+ if expr.has(bap1) and expr.has(bap2):
+ expr = expr.subs(ba, 2*(a+1)/x*bap1 - bap2)
+ break
+ else:
+ return expr
+ except (ValueError, TypeError):
+ return expr
+ if expr.has(besselj):
+ expr = _use_recursion(besselj, expr)
+ if expr.has(bessely):
+ expr = _use_recursion(bessely, expr)
+ return expr
+
+ expr = _bessel_simp_recursion(expr)
+ if expr != orig_expr:
+ expr = expr.factor()
+
+ return expr
+
+
+def nthroot(expr, n, max_len=4, prec=15):
+ """
+ Compute a real nth-root of a sum of surds.
+
+ Parameters
+ ==========
+
+ expr : sum of surds
+ n : integer
+ max_len : maximum number of surds passed as constants to ``nsimplify``
+
+ Algorithm
+ =========
+
+ First ``nsimplify`` is used to get a candidate root; if it is not a
+ root the minimal polynomial is computed; the answer is one of its
+ roots.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.simplify import nthroot
+ >>> from sympy import sqrt
+ >>> nthroot(90 + 34*sqrt(7), 3)
+ sqrt(7) + 3
+
+ """
+ expr = sympify(expr)
+ n = sympify(n)
+ p = expr**Rational(1, n)
+ if not n.is_integer:
+ return p
+ if not _is_sum_surds(expr):
+ return p
+ surds = []
+ coeff_muls = [x.as_coeff_Mul() for x in expr.args]
+ for x, y in coeff_muls:
+ if not x.is_rational:
+ return p
+ if y is S.One:
+ continue
+ if not (y.is_Pow and y.exp == S.Half and y.base.is_integer):
+ return p
+ surds.append(y)
+ surds.sort()
+ surds = surds[:max_len]
+ if expr < 0 and n % 2 == 1:
+ p = (-expr)**Rational(1, n)
+ a = nsimplify(p, constants=surds)
+ res = a if _mexpand(a**n) == _mexpand(-expr) else p
+ return -res
+ a = nsimplify(p, constants=surds)
+ if _mexpand(a) is not _mexpand(p) and _mexpand(a**n) == _mexpand(expr):
+ return _mexpand(a)
+ expr = _nthroot_solve(expr, n, prec)
+ if expr is None:
+ return p
+ return expr
+
+
+def nsimplify(expr, constants=(), tolerance=None, full=False, rational=None,
+ rational_conversion='base10'):
+ """
+ Find a simple representation for a number or, if there are free symbols or
+ if ``rational=True``, then replace Floats with their Rational equivalents. If
+ no change is made and rational is not False then Floats will at least be
+ converted to Rationals.
+
+ Explanation
+ ===========
+
+ For numerical expressions, a simple formula that numerically matches the
+ given numerical expression is sought (and the input should be possible
+ to evalf to a precision of at least 30 digits).
+
+ Optionally, a list of (rationally independent) constants to
+ include in the formula may be given.
+
+ A lower tolerance may be set to find less exact matches. If no tolerance
+ is given then the least precise value will set the tolerance (e.g. Floats
+ default to 15 digits of precision, so would be tolerance=10**-15).
+
+ With ``full=True``, a more extensive search is performed
+ (this is useful to find simpler numbers when the tolerance
+ is set low).
+
+ When converting to rational, if rational_conversion='base10' (the default), then
+ convert floats to rationals using their base-10 (string) representation.
+ When rational_conversion='exact' it uses the exact, base-2 representation.
+
+ Examples
+ ========
+
+ >>> from sympy import nsimplify, sqrt, GoldenRatio, exp, I, pi
+ >>> nsimplify(4/(1+sqrt(5)), [GoldenRatio])
+ -2 + 2*GoldenRatio
+ >>> nsimplify((1/(exp(3*pi*I/5)+1)))
+ 1/2 - I*sqrt(sqrt(5)/10 + 1/4)
+ >>> nsimplify(I**I, [pi])
+ exp(-pi/2)
+ >>> nsimplify(pi, tolerance=0.01)
+ 22/7
+
+ >>> nsimplify(0.333333333333333, rational=True, rational_conversion='exact')
+ 6004799503160655/18014398509481984
+ >>> nsimplify(0.333333333333333, rational=True)
+ 1/3
+
+ See Also
+ ========
+
+ sympy.core.function.nfloat
+
+ """
+ try:
+ return sympify(as_int(expr))
+ except (TypeError, ValueError):
+ pass
+ expr = sympify(expr).xreplace({
+ Float('inf'): S.Infinity,
+ Float('-inf'): S.NegativeInfinity,
+ })
+ if expr is S.Infinity or expr is S.NegativeInfinity:
+ return expr
+ if rational or expr.free_symbols:
+ return _real_to_rational(expr, tolerance, rational_conversion)
+
+ # SymPy's default tolerance for Rationals is 15; other numbers may have
+ # lower tolerances set, so use them to pick the largest tolerance if None
+ # was given
+ if tolerance is None:
+ tolerance = 10**-min([15] +
+ [mpmath.libmp.libmpf.prec_to_dps(n._prec)
+ for n in expr.atoms(Float)])
+ # XXX should prec be set independent of tolerance or should it be computed
+ # from tolerance?
+ prec = 30
+ bprec = int(prec*3.33)
+
+ constants_dict = {}
+ for constant in constants:
+ constant = sympify(constant)
+ v = constant.evalf(prec)
+ if not v.is_Float:
+ raise ValueError("constants must be real-valued")
+ constants_dict[str(constant)] = v._to_mpmath(bprec)
+
+ exprval = expr.evalf(prec, chop=True)
+ re, im = exprval.as_real_imag()
+
+ # safety check to make sure that this evaluated to a number
+ if not (re.is_Number and im.is_Number):
+ return expr
+
+ def nsimplify_real(x):
+ orig = mpmath.mp.dps
+ xv = x._to_mpmath(bprec)
+ try:
+ # We'll be happy with low precision if a simple fraction
+ if not (tolerance or full):
+ mpmath.mp.dps = 15
+ rat = mpmath.pslq([xv, 1])
+ if rat is not None:
+ return Rational(-int(rat[1]), int(rat[0]))
+ mpmath.mp.dps = prec
+ newexpr = mpmath.identify(xv, constants=constants_dict,
+ tol=tolerance, full=full)
+ if not newexpr:
+ raise ValueError
+ if full:
+ newexpr = newexpr[0]
+ expr = sympify(newexpr)
+ if x and not expr: # don't let x become 0
+ raise ValueError
+ if expr.is_finite is False and xv not in [mpmath.inf, mpmath.ninf]:
+ raise ValueError
+ return expr
+ finally:
+ # even though there are returns above, this is executed
+ # before leaving
+ mpmath.mp.dps = orig
+ try:
+ if re:
+ re = nsimplify_real(re)
+ if im:
+ im = nsimplify_real(im)
+ except ValueError:
+ if rational is None:
+ return _real_to_rational(expr, rational_conversion=rational_conversion)
+ return expr
+
+ rv = re + im*S.ImaginaryUnit
+ # if there was a change or rational is explicitly not wanted
+ # return the value, else return the Rational representation
+ if rv != expr or rational is False:
+ return rv
+ return _real_to_rational(expr, rational_conversion=rational_conversion)
+
+
+def _real_to_rational(expr, tolerance=None, rational_conversion='base10'):
+ """
+ Replace all reals in expr with rationals.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.simplify import _real_to_rational
+ >>> from sympy.abc import x
+
+ >>> _real_to_rational(.76 + .1*x**.5)
+ sqrt(x)/10 + 19/25
+
+ If rational_conversion='base10', this uses the base-10 string. If
+ rational_conversion='exact', the exact, base-2 representation is used.
+
+ >>> _real_to_rational(0.333333333333333, rational_conversion='exact')
+ 6004799503160655/18014398509481984
+ >>> _real_to_rational(0.333333333333333)
+ 1/3
+
+ """
+ expr = _sympify(expr)
+ inf = Float('inf')
+ p = expr
+ reps = {}
+ reduce_num = None
+ if tolerance is not None and tolerance < 1:
+ reduce_num = ceiling(1/tolerance)
+ for fl in p.atoms(Float):
+ key = fl
+ if reduce_num is not None:
+ r = Rational(fl).limit_denominator(reduce_num)
+ elif (tolerance is not None and tolerance >= 1 and
+ fl.is_Integer is False):
+ r = Rational(tolerance*round(fl/tolerance)
+ ).limit_denominator(int(tolerance))
+ else:
+ if rational_conversion == 'exact':
+ r = Rational(fl)
+ reps[key] = r
+ continue
+ elif rational_conversion != 'base10':
+ raise ValueError("rational_conversion must be 'base10' or 'exact'")
+
+ r = nsimplify(fl, rational=False)
+ # e.g. log(3).n() -> log(3) instead of a Rational
+ if fl and not r:
+ r = Rational(fl)
+ elif not r.is_Rational:
+ if fl in (inf, -inf):
+ r = S.ComplexInfinity
+ elif fl < 0:
+ fl = -fl
+ d = Pow(10, int(mpmath.log(fl)/mpmath.log(10)))
+ r = -Rational(str(fl/d))*d
+ elif fl > 0:
+ d = Pow(10, int(mpmath.log(fl)/mpmath.log(10)))
+ r = Rational(str(fl/d))*d
+ else:
+ r = S.Zero
+ reps[key] = r
+ return p.subs(reps, simultaneous=True)
+
+
+def clear_coefficients(expr, rhs=S.Zero):
+ """Return `p, r` where `p` is the expression obtained when Rational
+ additive and multiplicative coefficients of `expr` have been stripped
+ away in a naive fashion (i.e. without simplification). The operations
+ needed to remove the coefficients will be applied to `rhs` and returned
+ as `r`.
+
+ Examples
+ ========
+
+ >>> from sympy.simplify.simplify import clear_coefficients
+ >>> from sympy.abc import x, y
+ >>> from sympy import Dummy
+ >>> expr = 4*y*(6*x + 3)
+ >>> clear_coefficients(expr - 2)
+ (y*(2*x + 1), 1/6)
+
+ When solving 2 or more expressions like `expr = a`,
+ `expr = b`, etc..., it is advantageous to provide a Dummy symbol
+ for `rhs` and simply replace it with `a`, `b`, etc... in `r`.
+
+ >>> rhs = Dummy('rhs')
+ >>> clear_coefficients(expr, rhs)
+ (y*(2*x + 1), _rhs/12)
+ >>> _[1].subs(rhs, 2)
+ 1/6
+ """
+ was = None
+ free = expr.free_symbols
+ if expr.is_Rational:
+ return (S.Zero, rhs - expr)
+ while expr and was != expr:
+ was = expr
+ m, expr = (
+ expr.as_content_primitive()
+ if free else
+ factor_terms(expr).as_coeff_Mul(rational=True))
+ rhs /= m
+ c, expr = expr.as_coeff_Add(rational=True)
+ rhs -= c
+ expr = signsimp(expr, evaluate = False)
+ if expr.could_extract_minus_sign():
+ expr = -expr
+ rhs = -rhs
+ return expr, rhs
+
+def nc_simplify(expr, deep=True):
+ '''
+ Simplify a non-commutative expression composed of multiplication
+ and raising to a power by grouping repeated subterms into one power.
+ Priority is given to simplifications that give the fewest number
+ of arguments in the end (for example, in a*b*a*b*c*a*b*c simplifying
+ to (a*b)**2*c*a*b*c gives 5 arguments while a*b*(a*b*c)**2 has 3).
+ If ``expr`` is a sum of such terms, the sum of the simplified terms
+ is returned.
+
+ Keyword argument ``deep`` controls whether or not subexpressions
+ nested deeper inside the main expression are simplified. See examples
+ below. Setting `deep` to `False` can save time on nested expressions
+ that do not need simplifying on all levels.
+
+ Examples
+ ========
+
+ >>> from sympy import symbols
+ >>> from sympy.simplify.simplify import nc_simplify
+ >>> a, b, c = symbols("a b c", commutative=False)
+ >>> nc_simplify(a*b*a*b*c*a*b*c)
+ a*b*(a*b*c)**2
+ >>> expr = a**2*b*a**4*b*a**4
+ >>> nc_simplify(expr)
+ a**2*(b*a**4)**2
+ >>> nc_simplify(a*b*a*b*c**2*(a*b)**2*c**2)
+ ((a*b)**2*c**2)**2
+ >>> nc_simplify(a*b*a*b + 2*a*c*a**2*c*a**2*c*a)
+ (a*b)**2 + 2*(a*c*a)**3
+ >>> nc_simplify(b**-1*a**-1*(a*b)**2)
+ a*b
+ >>> nc_simplify(a**-1*b**-1*c*a)
+ (b*a)**(-1)*c*a
+ >>> expr = (a*b*a*b)**2*a*c*a*c
+ >>> nc_simplify(expr)
+ (a*b)**4*(a*c)**2
+ >>> nc_simplify(expr, deep=False)
+ (a*b*a*b)**2*(a*c)**2
+
+ '''
+ if isinstance(expr, MatrixExpr):
+ expr = expr.doit(inv_expand=False)
+ _Add, _Mul, _Pow, _Symbol = MatAdd, MatMul, MatPow, MatrixSymbol
+ else:
+ _Add, _Mul, _Pow, _Symbol = Add, Mul, Pow, Symbol
+
+ # =========== Auxiliary functions ========================
+ def _overlaps(args):
+ # Calculate a list of lists m such that m[i][j] contains the lengths
+ # of all possible overlaps between args[:i+1] and args[i+1+j:].
+ # An overlap is a suffix of the prefix that matches a prefix
+ # of the suffix.
+ # For example, let expr=c*a*b*a*b*a*b*a*b. Then m[3][0] contains
+ # the lengths of overlaps of c*a*b*a*b with a*b*a*b. The overlaps
+ # are a*b*a*b, a*b and the empty word so that m[3][0]=[4,2,0].
+ # All overlaps rather than only the longest one are recorded
+ # because this information helps calculate other overlap lengths.
+ m = [[([1, 0] if a == args[0] else [0]) for a in args[1:]]]
+ for i in range(1, len(args)):
+ overlaps = []
+ j = 0
+ for j in range(len(args) - i - 1):
+ overlap = []
+ for v in m[i-1][j+1]:
+ if j + i + 1 + v < len(args) and args[i] == args[j+i+1+v]:
+ overlap.append(v + 1)
+ overlap += [0]
+ overlaps.append(overlap)
+ m.append(overlaps)
+ return m
+
+ def _reduce_inverses(_args):
+ # replace consecutive negative powers by an inverse
+ # of a product of positive powers, e.g. a**-1*b**-1*c
+ # will simplify to (a*b)**-1*c;
+ # return that new args list and the number of negative
+ # powers in it (inv_tot)
+ inv_tot = 0 # total number of inverses
+ inverses = []
+ args = []
+ for arg in _args:
+ if isinstance(arg, _Pow) and arg.args[1].is_extended_negative:
+ inverses = [arg**-1] + inverses
+ inv_tot += 1
+ else:
+ if len(inverses) == 1:
+ args.append(inverses[0]**-1)
+ elif len(inverses) > 1:
+ args.append(_Pow(_Mul(*inverses), -1))
+ inv_tot -= len(inverses) - 1
+ inverses = []
+ args.append(arg)
+ if inverses:
+ args.append(_Pow(_Mul(*inverses), -1))
+ inv_tot -= len(inverses) - 1
+ return inv_tot, tuple(args)
+
+ def get_score(s):
+ # compute the number of arguments of s
+ # (including in nested expressions) overall
+ # but ignore exponents
+ if isinstance(s, _Pow):
+ return get_score(s.args[0])
+ elif isinstance(s, (_Add, _Mul)):
+ return sum(get_score(a) for a in s.args)
+ return 1
+
+ def compare(s, alt_s):
+ # compare two possible simplifications and return a
+ # "better" one
+ if s != alt_s and get_score(alt_s) < get_score(s):
+ return alt_s
+ return s
+ # ========================================================
+
+ if not isinstance(expr, (_Add, _Mul, _Pow)) or expr.is_commutative:
+ return expr
+ args = expr.args[:]
+ if isinstance(expr, _Pow):
+ if deep:
+ return _Pow(nc_simplify(args[0]), args[1]).doit()
+ else:
+ return expr
+ elif isinstance(expr, _Add):
+ return _Add(*[nc_simplify(a, deep=deep) for a in args]).doit()
+ else:
+ # get the non-commutative part
+ c_args, args = expr.args_cnc()
+ com_coeff = Mul(*c_args)
+ if not equal_valued(com_coeff, 1):
+ return com_coeff*nc_simplify(expr/com_coeff, deep=deep)
+
+ inv_tot, args = _reduce_inverses(args)
+ # if most arguments are negative, work with the inverse
+ # of the expression, e.g. a**-1*b*a**-1*c**-1 will become
+ # (c*a*b**-1*a)**-1 at the end so can work with c*a*b**-1*a
+ invert = False
+ if inv_tot > len(args)/2:
+ invert = True
+ args = [a**-1 for a in args[::-1]]
+
+ if deep:
+ args = tuple(nc_simplify(a) for a in args)
+
+ m = _overlaps(args)
+
+ # simps will be {subterm: end} where `end` is the ending
+ # index of a sequence of repetitions of subterm;
+ # this is for not wasting time with subterms that are part
+ # of longer, already considered sequences
+ simps = {}
+
+ post = 1
+ pre = 1
+
+ # the simplification coefficient is the number of
+ # arguments by which contracting a given sequence
+ # would reduce the word; e.g. in a*b*a*b*c*a*b*c,
+ # contracting a*b*a*b to (a*b)**2 removes 3 arguments
+ # while a*b*c*a*b*c to (a*b*c)**2 removes 6. It's
+ # better to contract the latter so simplification
+ # with a maximum simplification coefficient will be chosen
+ max_simp_coeff = 0
+ simp = None # information about future simplification
+
+ for i in range(1, len(args)):
+ simp_coeff = 0
+ l = 0 # length of a subterm
+ p = 0 # the power of a subterm
+ if i < len(args) - 1:
+ rep = m[i][0]
+ start = i # starting index of the repeated sequence
+ end = i+1 # ending index of the repeated sequence
+ if i == len(args)-1 or rep == [0]:
+ # no subterm is repeated at this stage, at least as
+ # far as the arguments are concerned - there may be
+ # a repetition if powers are taken into account
+ if (isinstance(args[i], _Pow) and
+ not isinstance(args[i].args[0], _Symbol)):
+ subterm = args[i].args[0].args
+ l = len(subterm)
+ if args[i-l:i] == subterm:
+ # e.g. a*b in a*b*(a*b)**2 is not repeated
+ # in args (= [a, b, (a*b)**2]) but it
+ # can be matched here
+ p += 1
+ start -= l
+ if args[i+1:i+1+l] == subterm:
+ # e.g. a*b in (a*b)**2*a*b
+ p += 1
+ end += l
+ if p:
+ p += args[i].args[1]
+ else:
+ continue
+ else:
+ l = rep[0] # length of the longest repeated subterm at this point
+ start -= l - 1
+ subterm = args[start:end]
+ p = 2
+ end += l
+
+ if subterm in simps and simps[subterm] >= start:
+ # the subterm is part of a sequence that
+ # has already been considered
+ continue
+
+ # count how many times it's repeated
+ while end < len(args):
+ if l in m[end-1][0]:
+ p += 1
+ end += l
+ elif isinstance(args[end], _Pow) and args[end].args[0].args == subterm:
+ # for cases like a*b*a*b*(a*b)**2*a*b
+ p += args[end].args[1]
+ end += 1
+ else:
+ break
+
+ # see if another match can be made, e.g.
+ # for b*a**2 in b*a**2*b*a**3 or a*b in
+ # a**2*b*a*b
+
+ pre_exp = 0
+ pre_arg = 1
+ if start - l >= 0 and args[start-l+1:start] == subterm[1:]:
+ if isinstance(subterm[0], _Pow):
+ pre_arg = subterm[0].args[0]
+ exp = subterm[0].args[1]
+ else:
+ pre_arg = subterm[0]
+ exp = 1
+ if isinstance(args[start-l], _Pow) and args[start-l].args[0] == pre_arg:
+ pre_exp = args[start-l].args[1] - exp
+ start -= l
+ p += 1
+ elif args[start-l] == pre_arg:
+ pre_exp = 1 - exp
+ start -= l
+ p += 1
+
+ post_exp = 0
+ post_arg = 1
+ if end + l - 1 < len(args) and args[end:end+l-1] == subterm[:-1]:
+ if isinstance(subterm[-1], _Pow):
+ post_arg = subterm[-1].args[0]
+ exp = subterm[-1].args[1]
+ else:
+ post_arg = subterm[-1]
+ exp = 1
+ if isinstance(args[end+l-1], _Pow) and args[end+l-1].args[0] == post_arg:
+ post_exp = args[end+l-1].args[1] - exp
+ end += l
+ p += 1
+ elif args[end+l-1] == post_arg:
+ post_exp = 1 - exp
+ end += l
+ p += 1
+
+ # Consider a*b*a**2*b*a**2*b*a:
+ # b*a**2 is explicitly repeated, but note
+ # that in this case a*b*a is also repeated
+ # so there are two possible simplifications:
+ # a*(b*a**2)**3*a**-1 or (a*b*a)**3
+ # The latter is obviously simpler.
+ # But in a*b*a**2*b**2*a**2 the simplifications are
+ # a*(b*a**2)**2 and (a*b*a)**3*a in which case
+ # it's better to stick with the shorter subterm
+ if post_exp and exp % 2 == 0 and start > 0:
+ exp = exp/2
+ _pre_exp = 1
+ _post_exp = 1
+ if isinstance(args[start-1], _Pow) and args[start-1].args[0] == post_arg:
+ _post_exp = post_exp + exp
+ _pre_exp = args[start-1].args[1] - exp
+ elif args[start-1] == post_arg:
+ _post_exp = post_exp + exp
+ _pre_exp = 1 - exp
+ if _pre_exp == 0 or _post_exp == 0:
+ if not pre_exp:
+ start -= 1
+ post_exp = _post_exp
+ pre_exp = _pre_exp
+ pre_arg = post_arg
+ subterm = (post_arg**exp,) + subterm[:-1] + (post_arg**exp,)
+
+ simp_coeff += end-start
+
+ if post_exp:
+ simp_coeff -= 1
+ if pre_exp:
+ simp_coeff -= 1
+
+ simps[subterm] = end
+
+ if simp_coeff > max_simp_coeff:
+ max_simp_coeff = simp_coeff
+ simp = (start, _Mul(*subterm), p, end, l)
+ pre = pre_arg**pre_exp
+ post = post_arg**post_exp
+
+ if simp:
+ subterm = _Pow(nc_simplify(simp[1], deep=deep), simp[2])
+ pre = nc_simplify(_Mul(*args[:simp[0]])*pre, deep=deep)
+ post = post*nc_simplify(_Mul(*args[simp[3]:]), deep=deep)
+ simp = pre*subterm*post
+ if pre != 1 or post != 1:
+ # new simplifications may be possible but no need
+ # to recurse over arguments
+ simp = nc_simplify(simp, deep=False)
+ else:
+ simp = _Mul(*args)
+
+ if invert:
+ simp = _Pow(simp, -1)
+
+ # see if factor_nc(expr) is simplified better
+ if not isinstance(expr, MatrixExpr):
+ f_expr = factor_nc(expr)
+ if f_expr != expr:
+ alt_simp = nc_simplify(f_expr, deep=deep)
+ simp = compare(simp, alt_simp)
+ else:
+ simp = simp.doit(inv_expand=False)
+ return simp
+
+
+def dotprodsimp(expr, withsimp=False):
+ """Simplification for a sum of products targeted at the kind of blowup that
+ occurs during summation of products. Intended to reduce expression blowup
+ during matrix multiplication or other similar operations. Only works with
+ algebraic expressions and does not recurse into non.
+
+ Parameters
+ ==========
+
+ withsimp : bool, optional
+ Specifies whether a flag should be returned along with the expression
+ to indicate roughly whether simplification was successful. It is used
+ in ``MatrixArithmetic._eval_pow_by_recursion`` to avoid attempting to
+ simplify an expression repetitively which does not simplify.
+ """
+
+ def count_ops_alg(expr):
+ """Optimized count algebraic operations with no recursion into
+ non-algebraic args that ``core.function.count_ops`` does. Also returns
+ whether rational functions may be present according to negative
+ exponents of powers or non-number fractions.
+
+ Returns
+ =======
+
+ ops, ratfunc : int, bool
+ ``ops`` is the number of algebraic operations starting at the top
+ level expression (not recursing into non-alg children). ``ratfunc``
+ specifies whether the expression MAY contain rational functions
+ which ``cancel`` MIGHT optimize.
+ """
+
+ ops = 0
+ args = [expr]
+ ratfunc = False
+
+ while args:
+ a = args.pop()
+
+ if not isinstance(a, Basic):
+ continue
+
+ if a.is_Rational:
+ if a is not S.One: # -1/3 = NEG + DIV
+ ops += bool (a.p < 0) + bool (a.q != 1)
+
+ elif a.is_Mul:
+ if a.could_extract_minus_sign():
+ ops += 1
+ if a.args[0] is S.NegativeOne:
+ a = a.as_two_terms()[1]
+ else:
+ a = -a
+
+ n, d = fraction(a)
+
+ if n.is_Integer:
+ ops += 1 + bool (n < 0)
+ args.append(d) # won't be -Mul but could be Add
+
+ elif d is not S.One:
+ if not d.is_Integer:
+ args.append(d)
+ ratfunc=True
+
+ ops += 1
+ args.append(n) # could be -Mul
+
+ else:
+ ops += len(a.args) - 1
+ args.extend(a.args)
+
+ elif a.is_Add:
+ laargs = len(a.args)
+ negs = 0
+
+ for ai in a.args:
+ if ai.could_extract_minus_sign():
+ negs += 1
+ ai = -ai
+ args.append(ai)
+
+ ops += laargs - (negs != laargs) # -x - y = NEG + SUB
+
+ elif a.is_Pow:
+ ops += 1
+ args.append(a.base)
+
+ if not ratfunc:
+ ratfunc = a.exp.is_negative is not False
+
+ return ops, ratfunc
+
+ def nonalg_subs_dummies(expr, dummies):
+ """Substitute dummy variables for non-algebraic expressions to avoid
+ evaluation of non-algebraic terms that ``polys.polytools.cancel`` does.
+ """
+
+ if not expr.args:
+ return expr
+
+ if expr.is_Add or expr.is_Mul or expr.is_Pow:
+ args = None
+
+ for i, a in enumerate(expr.args):
+ c = nonalg_subs_dummies(a, dummies)
+
+ if c is a:
+ continue
+
+ if args is None:
+ args = list(expr.args)
+
+ args[i] = c
+
+ if args is None:
+ return expr
+
+ return expr.func(*args)
+
+ return dummies.setdefault(expr, Dummy())
+
+ simplified = False # doesn't really mean simplified, rather "can simplify again"
+
+ if isinstance(expr, Basic) and (expr.is_Add or expr.is_Mul or expr.is_Pow):
+ expr2 = expr.expand(deep=True, modulus=None, power_base=False,
+ power_exp=False, mul=True, log=False, multinomial=True, basic=False)
+
+ if expr2 != expr:
+ expr = expr2
+ simplified = True
+
+ exprops, ratfunc = count_ops_alg(expr)
+
+ if exprops >= 6: # empirically tested cutoff for expensive simplification
+ if ratfunc:
+ dummies = {}
+ expr2 = nonalg_subs_dummies(expr, dummies)
+
+ if expr2 is expr or count_ops_alg(expr2)[0] >= 6: # check again after substitution
+ expr3 = cancel(expr2)
+
+ if expr3 != expr2:
+ expr = expr3.subs([(d, e) for e, d in dummies.items()])
+ simplified = True
+
+ # very special case: x/(x-1) - 1/(x-1) -> 1
+ elif (exprops == 5 and expr.is_Add and expr.args [0].is_Mul and
+ expr.args [1].is_Mul and expr.args [0].args [-1].is_Pow and
+ expr.args [1].args [-1].is_Pow and
+ expr.args [0].args [-1].exp is S.NegativeOne and
+ expr.args [1].args [-1].exp is S.NegativeOne):
+
+ expr2 = together (expr)
+ expr2ops = count_ops_alg(expr2)[0]
+
+ if expr2ops < exprops:
+ expr = expr2
+ simplified = True
+
+ else:
+ simplified = True
+
+ return (expr, simplified) if withsimp else expr
+
+
+bottom_up = deprecated(
+ """
+ Using bottom_up from the sympy.simplify.simplify submodule is
+ deprecated.
+
+ Instead, use bottom_up from the top-level sympy namespace, like
+
+ sympy.bottom_up
+ """,
+ deprecated_since_version="1.10",
+ active_deprecations_target="deprecated-traversal-functions-moved",
+)(_bottom_up)
+
+
+# XXX: This function really should either be private API or exported in the
+# top-level sympy/__init__.py
+walk = deprecated(
+ """
+ Using walk from the sympy.simplify.simplify submodule is
+ deprecated.
+
+ Instead, use walk from sympy.core.traversal.walk
+ """,
+ deprecated_since_version="1.10",
+ active_deprecations_target="deprecated-traversal-functions-moved",
+)(_walk)
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/__init__.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..192c13859aa5ce4466a686ab219a11748269421c
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/__init__.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_combsimp.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_combsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ccc9c2443d2ac1bfe446b1bcd6f19156da24eff5
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_combsimp.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_cse.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_cse.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8a253e559f6a4b39ab8beb1fa8d8c7622830c7e7
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_cse.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_epathtools.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_epathtools.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2d08a929aae1a883a5dd50bd11d25ed9f24ebcf4
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_epathtools.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_fu.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_fu.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..875c88296f1f7633d0c9495bec24489bef8bb7cf
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_fu.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_function.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_function.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..55ca539f63239b2feaa77c2f20abed687d079175
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_function.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_gammasimp.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_gammasimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0d9473d65042a26f49618bc37803366de45cd4dc
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_gammasimp.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_hyperexpand.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_hyperexpand.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f9f7f4c7f4f04e56a444e489f7e9a9e2b8d3a35a
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_hyperexpand.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_powsimp.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_powsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..764911981b3c9f286f39e61c95acc459468ebe43
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_powsimp.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_radsimp.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_radsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..286c77c72c3dbefb7a7149922d4e1888910ed356
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_radsimp.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_ratsimp.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_ratsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..735e385bfc4dbc9495fde8e2408bf9583920de9f
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_ratsimp.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_rewrite.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_rewrite.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c10969f9a2e9c2596d3d55f1d5bcfbf17b0daea7
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_rewrite.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_simplify.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_simplify.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5e03b7689c9b3bdd8cfaae909a4b891207d17427
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_simplify.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_trigsimp.cpython-310.pyc b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_trigsimp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aba1dd3431c0f89427065a09ec1c260af041f719
Binary files /dev/null and b/janus/lib/python3.10/site-packages/sympy/simplify/tests/__pycache__/test_trigsimp.cpython-310.pyc differ
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_cse.py b/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_cse.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e3955252ee65b1f7d949c23822508b7ef0a0dd9
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_cse.py
@@ -0,0 +1,758 @@
+from functools import reduce
+import itertools
+from operator import add
+
+from sympy.codegen.matrix_nodes import MatrixSolve
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.expr import UnevaluatedExpr
+from sympy.core.function import Function
+from sympy.core.mul import Mul
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions import Inverse, MatAdd, MatMul, Transpose
+from sympy.polys.rootoftools import CRootOf
+from sympy.series.order import O
+from sympy.simplify.cse_main import cse
+from sympy.simplify.simplify import signsimp
+from sympy.tensor.indexed import (Idx, IndexedBase)
+
+from sympy.core.function import count_ops
+from sympy.simplify.cse_opts import sub_pre, sub_post
+from sympy.functions.special.hyper import meijerg
+from sympy.simplify import cse_main, cse_opts
+from sympy.utilities.iterables import subsets
+from sympy.testing.pytest import XFAIL, raises
+from sympy.matrices import (MutableDenseMatrix, MutableSparseMatrix,
+ ImmutableDenseMatrix, ImmutableSparseMatrix)
+from sympy.matrices.expressions import MatrixSymbol
+
+
+w, x, y, z = symbols('w,x,y,z')
+x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12 = symbols('x:13')
+
+
+def test_numbered_symbols():
+ ns = cse_main.numbered_symbols(prefix='y')
+ assert list(itertools.islice(
+ ns, 0, 10)) == [Symbol('y%s' % i) for i in range(0, 10)]
+ ns = cse_main.numbered_symbols(prefix='y')
+ assert list(itertools.islice(
+ ns, 10, 20)) == [Symbol('y%s' % i) for i in range(10, 20)]
+ ns = cse_main.numbered_symbols()
+ assert list(itertools.islice(
+ ns, 0, 10)) == [Symbol('x%s' % i) for i in range(0, 10)]
+
+# Dummy "optimization" functions for testing.
+
+
+def opt1(expr):
+ return expr + y
+
+
+def opt2(expr):
+ return expr*z
+
+
+def test_preprocess_for_cse():
+ assert cse_main.preprocess_for_cse(x, [(opt1, None)]) == x + y
+ assert cse_main.preprocess_for_cse(x, [(None, opt1)]) == x
+ assert cse_main.preprocess_for_cse(x, [(None, None)]) == x
+ assert cse_main.preprocess_for_cse(x, [(opt1, opt2)]) == x + y
+ assert cse_main.preprocess_for_cse(
+ x, [(opt1, None), (opt2, None)]) == (x + y)*z
+
+
+def test_postprocess_for_cse():
+ assert cse_main.postprocess_for_cse(x, [(opt1, None)]) == x
+ assert cse_main.postprocess_for_cse(x, [(None, opt1)]) == x + y
+ assert cse_main.postprocess_for_cse(x, [(None, None)]) == x
+ assert cse_main.postprocess_for_cse(x, [(opt1, opt2)]) == x*z
+ # Note the reverse order of application.
+ assert cse_main.postprocess_for_cse(
+ x, [(None, opt1), (None, opt2)]) == x*z + y
+
+
+def test_cse_single():
+ # Simple substitution.
+ e = Add(Pow(x + y, 2), sqrt(x + y))
+ substs, reduced = cse([e])
+ assert substs == [(x0, x + y)]
+ assert reduced == [sqrt(x0) + x0**2]
+
+ subst42, (red42,) = cse([42]) # issue_15082
+ assert len(subst42) == 0 and red42 == 42
+ subst_half, (red_half,) = cse([0.5])
+ assert len(subst_half) == 0 and red_half == 0.5
+
+
+def test_cse_single2():
+ # Simple substitution, test for being able to pass the expression directly
+ e = Add(Pow(x + y, 2), sqrt(x + y))
+ substs, reduced = cse(e)
+ assert substs == [(x0, x + y)]
+ assert reduced == [sqrt(x0) + x0**2]
+ substs, reduced = cse(Matrix([[1]]))
+ assert isinstance(reduced[0], Matrix)
+
+ subst42, (red42,) = cse(42) # issue 15082
+ assert len(subst42) == 0 and red42 == 42
+ subst_half, (red_half,) = cse(0.5) # issue 15082
+ assert len(subst_half) == 0 and red_half == 0.5
+
+
+def test_cse_not_possible():
+ # No substitution possible.
+ e = Add(x, y)
+ substs, reduced = cse([e])
+ assert substs == []
+ assert reduced == [x + y]
+ # issue 6329
+ eq = (meijerg((1, 2), (y, 4), (5,), [], x) +
+ meijerg((1, 3), (y, 4), (5,), [], x))
+ assert cse(eq) == ([], [eq])
+
+
+def test_nested_substitution():
+ # Substitution within a substitution.
+ e = Add(Pow(w*x + y, 2), sqrt(w*x + y))
+ substs, reduced = cse([e])
+ assert substs == [(x0, w*x + y)]
+ assert reduced == [sqrt(x0) + x0**2]
+
+
+def test_subtraction_opt():
+ # Make sure subtraction is optimized.
+ e = (x - y)*(z - y) + exp((x - y)*(z - y))
+ substs, reduced = cse(
+ [e], optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)])
+ assert substs == [(x0, (x - y)*(y - z))]
+ assert reduced == [-x0 + exp(-x0)]
+ e = -(x - y)*(z - y) + exp(-(x - y)*(z - y))
+ substs, reduced = cse(
+ [e], optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)])
+ assert substs == [(x0, (x - y)*(y - z))]
+ assert reduced == [x0 + exp(x0)]
+ # issue 4077
+ n = -1 + 1/x
+ e = n/x/(-n)**2 - 1/n/x
+ assert cse(e, optimizations=[(cse_opts.sub_pre, cse_opts.sub_post)]) == \
+ ([], [0])
+ assert cse(((w + x + y + z)*(w - y - z))/(w + x)**3) == \
+ ([(x0, w + x), (x1, y + z)], [(w - x1)*(x0 + x1)/x0**3])
+
+
+def test_multiple_expressions():
+ e1 = (x + y)*z
+ e2 = (x + y)*w
+ substs, reduced = cse([e1, e2])
+ assert substs == [(x0, x + y)]
+ assert reduced == [x0*z, x0*w]
+ l = [w*x*y + z, w*y]
+ substs, reduced = cse(l)
+ rsubsts, _ = cse(reversed(l))
+ assert substs == rsubsts
+ assert reduced == [z + x*x0, x0]
+ l = [w*x*y, w*x*y + z, w*y]
+ substs, reduced = cse(l)
+ rsubsts, _ = cse(reversed(l))
+ assert substs == rsubsts
+ assert reduced == [x1, x1 + z, x0]
+ l = [(x - z)*(y - z), x - z, y - z]
+ substs, reduced = cse(l)
+ rsubsts, _ = cse(reversed(l))
+ assert substs == [(x0, -z), (x1, x + x0), (x2, x0 + y)]
+ assert rsubsts == [(x0, -z), (x1, x0 + y), (x2, x + x0)]
+ assert reduced == [x1*x2, x1, x2]
+ l = [w*y + w + x + y + z, w*x*y]
+ assert cse(l) == ([(x0, w*y)], [w + x + x0 + y + z, x*x0])
+ assert cse([x + y, x + y + z]) == ([(x0, x + y)], [x0, z + x0])
+ assert cse([x + y, x + z]) == ([], [x + y, x + z])
+ assert cse([x*y, z + x*y, x*y*z + 3]) == \
+ ([(x0, x*y)], [x0, z + x0, 3 + x0*z])
+
+
+@XFAIL # CSE of non-commutative Mul terms is disabled
+def test_non_commutative_cse():
+ A, B, C = symbols('A B C', commutative=False)
+ l = [A*B*C, A*C]
+ assert cse(l) == ([], l)
+ l = [A*B*C, A*B]
+ assert cse(l) == ([(x0, A*B)], [x0*C, x0])
+
+
+# Test if CSE of non-commutative Mul terms is disabled
+def test_bypass_non_commutatives():
+ A, B, C = symbols('A B C', commutative=False)
+ l = [A*B*C, A*C]
+ assert cse(l) == ([], l)
+ l = [A*B*C, A*B]
+ assert cse(l) == ([], l)
+ l = [B*C, A*B*C]
+ assert cse(l) == ([], l)
+
+
+@XFAIL # CSE fails when replacing non-commutative sub-expressions
+def test_non_commutative_order():
+ A, B, C = symbols('A B C', commutative=False)
+ x0 = symbols('x0', commutative=False)
+ l = [B+C, A*(B+C)]
+ assert cse(l) == ([(x0, B+C)], [x0, A*x0])
+
+
+@XFAIL # Worked in gh-11232, but was reverted due to performance considerations
+def test_issue_10228():
+ assert cse([x*y**2 + x*y]) == ([(x0, x*y)], [x0*y + x0])
+ assert cse([x + y, 2*x + y]) == ([(x0, x + y)], [x0, x + x0])
+ assert cse((w + 2*x + y + z, w + x + 1)) == (
+ [(x0, w + x)], [x0 + x + y + z, x0 + 1])
+ assert cse(((w + x + y + z)*(w - x))/(w + x)) == (
+ [(x0, w + x)], [(x0 + y + z)*(w - x)/x0])
+ a, b, c, d, f, g, j, m = symbols('a, b, c, d, f, g, j, m')
+ exprs = (d*g**2*j*m, 4*a*f*g*m, a*b*c*f**2)
+ assert cse(exprs) == (
+ [(x0, g*m), (x1, a*f)], [d*g*j*x0, 4*x0*x1, b*c*f*x1]
+)
+
+@XFAIL
+def test_powers():
+ assert cse(x*y**2 + x*y) == ([(x0, x*y)], [x0*y + x0])
+
+
+def test_issue_4498():
+ assert cse(w/(x - y) + z/(y - x), optimizations='basic') == \
+ ([], [(w - z)/(x - y)])
+
+
+def test_issue_4020():
+ assert cse(x**5 + x**4 + x**3 + x**2, optimizations='basic') \
+ == ([(x0, x**2)], [x0*(x**3 + x + x0 + 1)])
+
+
+def test_issue_4203():
+ assert cse(sin(x**x)/x**x) == ([(x0, x**x)], [sin(x0)/x0])
+
+
+def test_issue_6263():
+ e = Eq(x*(-x + 1) + x*(x - 1), 0)
+ assert cse(e, optimizations='basic') == ([], [True])
+
+
+def test_issue_25043():
+ c = symbols("c")
+ x = symbols("x0", real=True)
+ cse_expr = cse(c*x**2 + c*(x**4 - x**2))[-1][-1]
+ free = cse_expr.free_symbols
+ assert len(free) == len({i.name for i in free})
+
+
+def test_dont_cse_tuples():
+ from sympy.core.function import Subs
+ f = Function("f")
+ g = Function("g")
+
+ name_val, (expr,) = cse(
+ Subs(f(x, y), (x, y), (0, 1))
+ + Subs(g(x, y), (x, y), (0, 1)))
+
+ assert name_val == []
+ assert expr == (Subs(f(x, y), (x, y), (0, 1))
+ + Subs(g(x, y), (x, y), (0, 1)))
+
+ name_val, (expr,) = cse(
+ Subs(f(x, y), (x, y), (0, x + y))
+ + Subs(g(x, y), (x, y), (0, x + y)))
+
+ assert name_val == [(x0, x + y)]
+ assert expr == Subs(f(x, y), (x, y), (0, x0)) + \
+ Subs(g(x, y), (x, y), (0, x0))
+
+
+def test_pow_invpow():
+ assert cse(1/x**2 + x**2) == \
+ ([(x0, x**2)], [x0 + 1/x0])
+ assert cse(x**2 + (1 + 1/x**2)/x**2) == \
+ ([(x0, x**2), (x1, 1/x0)], [x0 + x1*(x1 + 1)])
+ assert cse(1/x**2 + (1 + 1/x**2)*x**2) == \
+ ([(x0, x**2), (x1, 1/x0)], [x0*(x1 + 1) + x1])
+ assert cse(cos(1/x**2) + sin(1/x**2)) == \
+ ([(x0, x**(-2))], [sin(x0) + cos(x0)])
+ assert cse(cos(x**2) + sin(x**2)) == \
+ ([(x0, x**2)], [sin(x0) + cos(x0)])
+ assert cse(y/(2 + x**2) + z/x**2/y) == \
+ ([(x0, x**2)], [y/(x0 + 2) + z/(x0*y)])
+ assert cse(exp(x**2) + x**2*cos(1/x**2)) == \
+ ([(x0, x**2)], [x0*cos(1/x0) + exp(x0)])
+ assert cse((1 + 1/x**2)/x**2) == \
+ ([(x0, x**(-2))], [x0*(x0 + 1)])
+ assert cse(x**(2*y) + x**(-2*y)) == \
+ ([(x0, x**(2*y))], [x0 + 1/x0])
+
+
+def test_postprocess():
+ eq = (x + 1 + exp((x + 1)/(y + 1)) + cos(y + 1))
+ assert cse([eq, Eq(x, z + 1), z - 2, (z + 1)*(x + 1)],
+ postprocess=cse_main.cse_separate) == \
+ [[(x0, y + 1), (x2, z + 1), (x, x2), (x1, x + 1)],
+ [x1 + exp(x1/x0) + cos(x0), z - 2, x1*x2]]
+
+
+def test_issue_4499():
+ # previously, this gave 16 constants
+ from sympy.abc import a, b
+ B = Function('B')
+ G = Function('G')
+ t = Tuple(*
+ (a, a + S.Half, 2*a, b, 2*a - b + 1, (sqrt(z)/2)**(-2*a + 1)*B(2*a -
+ b, sqrt(z))*B(b - 1, sqrt(z))*G(b)*G(2*a - b + 1),
+ sqrt(z)*(sqrt(z)/2)**(-2*a + 1)*B(b, sqrt(z))*B(2*a - b,
+ sqrt(z))*G(b)*G(2*a - b + 1), sqrt(z)*(sqrt(z)/2)**(-2*a + 1)*B(b - 1,
+ sqrt(z))*B(2*a - b + 1, sqrt(z))*G(b)*G(2*a - b + 1),
+ (sqrt(z)/2)**(-2*a + 1)*B(b, sqrt(z))*B(2*a - b + 1,
+ sqrt(z))*G(b)*G(2*a - b + 1), 1, 0, S.Half, z/2, -b + 1, -2*a + b,
+ -2*a))
+ c = cse(t)
+ ans = (
+ [(x0, 2*a), (x1, -b + x0), (x2, x1 + 1), (x3, b - 1), (x4, sqrt(z)),
+ (x5, B(x3, x4)), (x6, (x4/2)**(1 - x0)*G(b)*G(x2)), (x7, x6*B(x1, x4)),
+ (x8, B(b, x4)), (x9, x6*B(x2, x4))],
+ [(a, a + S.Half, x0, b, x2, x5*x7, x4*x7*x8, x4*x5*x9, x8*x9,
+ 1, 0, S.Half, z/2, -x3, -x1, -x0)])
+ assert ans == c
+
+
+def test_issue_6169():
+ r = CRootOf(x**6 - 4*x**5 - 2, 1)
+ assert cse(r) == ([], [r])
+ # and a check that the right thing is done with the new
+ # mechanism
+ assert sub_post(sub_pre((-x - y)*z - x - y)) == -z*(x + y) - x - y
+
+
+def test_cse_Indexed():
+ len_y = 5
+ y = IndexedBase('y', shape=(len_y,))
+ x = IndexedBase('x', shape=(len_y,))
+ i = Idx('i', len_y-1)
+
+ expr1 = (y[i+1]-y[i])/(x[i+1]-x[i])
+ expr2 = 1/(x[i+1]-x[i])
+ replacements, reduced_exprs = cse([expr1, expr2])
+ assert len(replacements) > 0
+
+
+def test_cse_MatrixSymbol():
+ # MatrixSymbols have non-Basic args, so make sure that works
+ A = MatrixSymbol("A", 3, 3)
+ assert cse(A) == ([], [A])
+
+ n = symbols('n', integer=True)
+ B = MatrixSymbol("B", n, n)
+ assert cse(B) == ([], [B])
+
+ assert cse(A[0] * A[0]) == ([], [A[0]*A[0]])
+
+ assert cse(A[0,0]*A[0,1] + A[0,0]*A[0,1]*A[0,2]) == ([(x0, A[0, 0]*A[0, 1])], [x0*A[0, 2] + x0])
+
+def test_cse_MatrixExpr():
+ A = MatrixSymbol('A', 3, 3)
+ y = MatrixSymbol('y', 3, 1)
+
+ expr1 = (A.T*A).I * A * y
+ expr2 = (A.T*A) * A * y
+ replacements, reduced_exprs = cse([expr1, expr2])
+ assert len(replacements) > 0
+
+ replacements, reduced_exprs = cse([expr1 + expr2, expr1])
+ assert replacements
+
+ replacements, reduced_exprs = cse([A**2, A + A**2])
+ assert replacements
+
+
+def test_Piecewise():
+ f = Piecewise((-z + x*y, Eq(y, 0)), (-z - x*y, True))
+ ans = cse(f)
+ actual_ans = ([(x0, x*y)],
+ [Piecewise((x0 - z, Eq(y, 0)), (-z - x0, True))])
+ assert ans == actual_ans
+
+
+def test_ignore_order_terms():
+ eq = exp(x).series(x,0,3) + sin(y+x**3) - 1
+ assert cse(eq) == ([], [sin(x**3 + y) + x + x**2/2 + O(x**3)])
+
+
+def test_name_conflict():
+ z1 = x0 + y
+ z2 = x2 + x3
+ l = [cos(z1) + z1, cos(z2) + z2, x0 + x2]
+ substs, reduced = cse(l)
+ assert [e.subs(reversed(substs)) for e in reduced] == l
+
+
+def test_name_conflict_cust_symbols():
+ z1 = x0 + y
+ z2 = x2 + x3
+ l = [cos(z1) + z1, cos(z2) + z2, x0 + x2]
+ substs, reduced = cse(l, symbols("x:10"))
+ assert [e.subs(reversed(substs)) for e in reduced] == l
+
+
+def test_symbols_exhausted_error():
+ l = cos(x+y)+x+y+cos(w+y)+sin(w+y)
+ sym = [x, y, z]
+ with raises(ValueError):
+ cse(l, symbols=sym)
+
+
+def test_issue_7840():
+ # daveknippers' example
+ C393 = sympify( \
+ 'Piecewise((C391 - 1.65, C390 < 0.5), (Piecewise((C391 - 1.65, \
+ C391 > 2.35), (C392, True)), True))'
+ )
+ C391 = sympify( \
+ 'Piecewise((2.05*C390**(-1.03), C390 < 0.5), (2.5*C390**(-0.625), True))'
+ )
+ C393 = C393.subs('C391',C391)
+ # simple substitution
+ sub = {}
+ sub['C390'] = 0.703451854
+ sub['C392'] = 1.01417794
+ ss_answer = C393.subs(sub)
+ # cse
+ substitutions,new_eqn = cse(C393)
+ for pair in substitutions:
+ sub[pair[0].name] = pair[1].subs(sub)
+ cse_answer = new_eqn[0].subs(sub)
+ # both methods should be the same
+ assert ss_answer == cse_answer
+
+ # GitRay's example
+ expr = sympify(
+ "Piecewise((Symbol('ON'), Equality(Symbol('mode'), Symbol('ON'))), \
+ (Piecewise((Piecewise((Symbol('OFF'), StrictLessThan(Symbol('x'), \
+ Symbol('threshold'))), (Symbol('ON'), true)), Equality(Symbol('mode'), \
+ Symbol('AUTO'))), (Symbol('OFF'), true)), true))"
+ )
+ substitutions, new_eqn = cse(expr)
+ # this Piecewise should be exactly the same
+ assert new_eqn[0] == expr
+ # there should not be any replacements
+ assert len(substitutions) < 1
+
+
+def test_issue_8891():
+ for cls in (MutableDenseMatrix, MutableSparseMatrix,
+ ImmutableDenseMatrix, ImmutableSparseMatrix):
+ m = cls(2, 2, [x + y, 0, 0, 0])
+ res = cse([x + y, m])
+ ans = ([(x0, x + y)], [x0, cls([[x0, 0], [0, 0]])])
+ assert res == ans
+ assert isinstance(res[1][-1], cls)
+
+
+def test_issue_11230():
+ # a specific test that always failed
+ a, b, f, k, l, i = symbols('a b f k l i')
+ p = [a*b*f*k*l, a*i*k**2*l, f*i*k**2*l]
+ R, C = cse(p)
+ assert not any(i.is_Mul for a in C for i in a.args)
+
+ # random tests for the issue
+ from sympy.core.random import choice
+ from sympy.core.function import expand_mul
+ s = symbols('a:m')
+ # 35 Mul tests, none of which should ever fail
+ ex = [Mul(*[choice(s) for i in range(5)]) for i in range(7)]
+ for p in subsets(ex, 3):
+ p = list(p)
+ R, C = cse(p)
+ assert not any(i.is_Mul for a in C for i in a.args)
+ for ri in reversed(R):
+ for i in range(len(C)):
+ C[i] = C[i].subs(*ri)
+ assert p == C
+ # 35 Add tests, none of which should ever fail
+ ex = [Add(*[choice(s[:7]) for i in range(5)]) for i in range(7)]
+ for p in subsets(ex, 3):
+ p = list(p)
+ R, C = cse(p)
+ assert not any(i.is_Add for a in C for i in a.args)
+ for ri in reversed(R):
+ for i in range(len(C)):
+ C[i] = C[i].subs(*ri)
+ # use expand_mul to handle cases like this:
+ # p = [a + 2*b + 2*e, 2*b + c + 2*e, b + 2*c + 2*g]
+ # x0 = 2*(b + e) is identified giving a rebuilt p that
+ # is now `[a + 2*(b + e), c + 2*(b + e), b + 2*c + 2*g]`
+ assert p == [expand_mul(i) for i in C]
+
+
+@XFAIL
+def test_issue_11577():
+ def check(eq):
+ r, c = cse(eq)
+ assert eq.count_ops() >= \
+ len(r) + sum(i[1].count_ops() for i in r) + \
+ count_ops(c)
+
+ eq = x**5*y**2 + x**5*y + x**5
+ assert cse(eq) == (
+ [(x0, x**4), (x1, x*y)], [x**5 + x0*x1*y + x0*x1])
+ # ([(x0, x**5*y)], [x0*y + x0 + x**5]) or
+ # ([(x0, x**5)], [x0*y**2 + x0*y + x0])
+ check(eq)
+
+ eq = x**2/(y + 1)**2 + x/(y + 1)
+ assert cse(eq) == (
+ [(x0, y + 1)], [x**2/x0**2 + x/x0])
+ # ([(x0, x/(y + 1))], [x0**2 + x0])
+ check(eq)
+
+
+def test_hollow_rejection():
+ eq = [x + 3, x + 4]
+ assert cse(eq) == ([], eq)
+
+
+def test_cse_ignore():
+ exprs = [exp(y)*(3*y + 3*sqrt(x+1)), exp(y)*(5*y + 5*sqrt(x+1))]
+ subst1, red1 = cse(exprs)
+ assert any(y in sub.free_symbols for _, sub in subst1), "cse failed to identify any term with y"
+
+ subst2, red2 = cse(exprs, ignore=(y,)) # y is not allowed in substitutions
+ assert not any(y in sub.free_symbols for _, sub in subst2), "Sub-expressions containing y must be ignored"
+ assert any(sub - sqrt(x + 1) == 0 for _, sub in subst2), "cse failed to identify sqrt(x + 1) as sub-expression"
+
+def test_cse_ignore_issue_15002():
+ l = [
+ w*exp(x)*exp(-z),
+ exp(y)*exp(x)*exp(-z)
+ ]
+ substs, reduced = cse(l, ignore=(x,))
+ rl = [e.subs(reversed(substs)) for e in reduced]
+ assert rl == l
+
+
+def test_cse_unevaluated():
+ xp1 = UnevaluatedExpr(x + 1)
+ # This used to cause RecursionError
+ [(x0, ue)], [red] = cse([(-1 - xp1) / (1 - xp1)])
+ if ue == xp1:
+ assert red == (-1 - x0) / (1 - x0)
+ elif ue == -xp1:
+ assert red == (-1 + x0) / (1 + x0)
+ else:
+ msg = f'Expected common subexpression {xp1} or {-xp1}, instead got {ue}'
+ assert False, msg
+
+
+def test_cse__performance():
+ nexprs, nterms = 3, 20
+ x = symbols('x:%d' % nterms)
+ exprs = [
+ reduce(add, [x[j]*(-1)**(i+j) for j in range(nterms)])
+ for i in range(nexprs)
+ ]
+ assert (exprs[0] + exprs[1]).simplify() == 0
+ subst, red = cse(exprs)
+ assert len(subst) > 0, "exprs[0] == -exprs[2], i.e. a CSE"
+ for i, e in enumerate(red):
+ assert (e.subs(reversed(subst)) - exprs[i]).simplify() == 0
+
+
+def test_issue_12070():
+ exprs = [x + y, 2 + x + y, x + y + z, 3 + x + y + z]
+ subst, red = cse(exprs)
+ assert 6 >= (len(subst) + sum(v.count_ops() for k, v in subst) +
+ count_ops(red))
+
+
+def test_issue_13000():
+ eq = x/(-4*x**2 + y**2)
+ cse_eq = cse(eq)[1][0]
+ assert cse_eq == eq
+
+
+def test_issue_18203():
+ eq = CRootOf(x**5 + 11*x - 2, 0) + CRootOf(x**5 + 11*x - 2, 1)
+ assert cse(eq) == ([], [eq])
+
+
+def test_unevaluated_mul():
+ eq = Mul(x + y, x + y, evaluate=False)
+ assert cse(eq) == ([(x0, x + y)], [x0**2])
+
+def test_cse_release_variables():
+ from sympy.simplify.cse_main import cse_release_variables
+ _0, _1, _2, _3, _4 = symbols('_:5')
+ eqs = [(x + y - 1)**2, x,
+ x + y, (x + y)/(2*x + 1) + (x + y - 1)**2,
+ (2*x + 1)**(x + y)]
+ r, e = cse(eqs, postprocess=cse_release_variables)
+ # this can change in keeping with the intention of the function
+ assert r, e == ([
+ (x0, x + y), (x1, (x0 - 1)**2), (x2, 2*x + 1),
+ (_3, x0/x2 + x1), (_4, x2**x0), (x2, None), (_0, x1),
+ (x1, None), (_2, x0), (x0, None), (_1, x)], (_0, _1, _2, _3, _4))
+ r.reverse()
+ r = [(s, v) for s, v in r if v is not None]
+ assert eqs == [i.subs(r) for i in e]
+
+def test_cse_list():
+ _cse = lambda x: cse(x, list=False)
+ assert _cse(x) == ([], x)
+ assert _cse('x') == ([], 'x')
+ it = [x]
+ for c in (list, tuple, set):
+ assert _cse(c(it)) == ([], c(it))
+ #Tuple works different from tuple:
+ assert _cse(Tuple(*it)) == ([], Tuple(*it))
+ d = {x: 1}
+ assert _cse(d) == ([], d)
+
+def test_issue_18991():
+ A = MatrixSymbol('A', 2, 2)
+ assert signsimp(-A * A - A) == -A * A - A
+
+
+def test_unevaluated_Mul():
+ m = [Mul(1, 2, evaluate=False)]
+ assert cse(m) == ([], m)
+
+
+def test_cse_matrix_expression_inverse():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ x = Inverse(A)
+ cse_expr = cse(x)
+ assert cse_expr == ([], [Inverse(A)])
+
+
+def test_cse_matrix_expression_matmul_inverse():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ b = ImmutableDenseMatrix(symbols('b:2'))
+ x = MatMul(Inverse(A), b)
+ cse_expr = cse(x)
+ assert cse_expr == ([], [x])
+
+
+def test_cse_matrix_negate_matrix():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ x = MatMul(S.NegativeOne, A)
+ cse_expr = cse(x)
+ assert cse_expr == ([], [x])
+
+
+def test_cse_matrix_negate_matmul_not_extracted():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ B = ImmutableDenseMatrix(symbols('B:4')).reshape(2, 2)
+ x = MatMul(S.NegativeOne, A, B)
+ cse_expr = cse(x)
+ assert cse_expr == ([], [x])
+
+
+@XFAIL # No simplification rule for nested associative operations
+def test_cse_matrix_nested_matmul_collapsed():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ B = ImmutableDenseMatrix(symbols('B:4')).reshape(2, 2)
+ x = MatMul(S.NegativeOne, MatMul(A, B))
+ cse_expr = cse(x)
+ assert cse_expr == ([], [MatMul(S.NegativeOne, A, B)])
+
+
+def test_cse_matrix_optimize_out_single_argument_mul():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ x = MatMul(MatMul(MatMul(A)))
+ cse_expr = cse(x)
+ assert cse_expr == ([], [A])
+
+
+@XFAIL # Multiple simplification passed not supported in CSE
+def test_cse_matrix_optimize_out_single_argument_mul_combined():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ x = MatAdd(MatMul(MatMul(MatMul(A))), MatMul(MatMul(A)), MatMul(A), A)
+ cse_expr = cse(x)
+ assert cse_expr == ([], [MatMul(4, A)])
+
+
+def test_cse_matrix_optimize_out_single_argument_add():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ x = MatAdd(MatAdd(MatAdd(MatAdd(A))))
+ cse_expr = cse(x)
+ assert cse_expr == ([], [A])
+
+
+@XFAIL # Multiple simplification passed not supported in CSE
+def test_cse_matrix_optimize_out_single_argument_add_combined():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ x = MatMul(MatAdd(MatAdd(MatAdd(A))), MatAdd(MatAdd(A)), MatAdd(A), A)
+ cse_expr = cse(x)
+ assert cse_expr == ([], [MatMul(4, A)])
+
+
+def test_cse_matrix_expression_matrix_solve():
+ A = ImmutableDenseMatrix(symbols('A:4')).reshape(2, 2)
+ b = ImmutableDenseMatrix(symbols('b:2'))
+ x = MatrixSolve(A, b)
+ cse_expr = cse(x)
+ assert cse_expr == ([], [x])
+
+
+def test_cse_matrix_matrix_expression():
+ X = ImmutableDenseMatrix(symbols('X:4')).reshape(2, 2)
+ y = ImmutableDenseMatrix(symbols('y:2'))
+ b = MatMul(Inverse(MatMul(Transpose(X), X)), Transpose(X), y)
+ cse_expr = cse(b)
+ x0 = MatrixSymbol('x0', 2, 2)
+ reduced_expr_expected = MatMul(Inverse(MatMul(x0, X)), x0, y)
+ assert cse_expr == ([(x0, Transpose(X))], [reduced_expr_expected])
+
+
+def test_cse_matrix_kalman_filter():
+ """Kalman Filter example from Matthew Rocklin's SciPy 2013 talk.
+
+ Talk titled: "Matrix Expressions and BLAS/LAPACK; SciPy 2013 Presentation"
+
+ Video: https://pyvideo.org/scipy-2013/matrix-expressions-and-blaslapack-scipy-2013-pr.html
+
+ Notes
+ =====
+
+ Equations are:
+
+ new_mu = mu + Sigma*H.T * (R + H*Sigma*H.T).I * (H*mu - data)
+ = MatAdd(mu, MatMul(Sigma, Transpose(H), Inverse(MatAdd(R, MatMul(H, Sigma, Transpose(H)))), MatAdd(MatMul(H, mu), MatMul(S.NegativeOne, data))))
+ new_Sigma = Sigma - Sigma*H.T * (R + H*Sigma*H.T).I * H * Sigma
+ = MatAdd(Sigma, MatMul(S.NegativeOne, Sigma, Transpose(H)), Inverse(MatAdd(R, MatMul(H*Sigma*Transpose(H)))), H, Sigma))
+
+ """
+ N = 2
+ mu = ImmutableDenseMatrix(symbols(f'mu:{N}'))
+ Sigma = ImmutableDenseMatrix(symbols(f'Sigma:{N * N}')).reshape(N, N)
+ H = ImmutableDenseMatrix(symbols(f'H:{N * N}')).reshape(N, N)
+ R = ImmutableDenseMatrix(symbols(f'R:{N * N}')).reshape(N, N)
+ data = ImmutableDenseMatrix(symbols(f'data:{N}'))
+ new_mu = MatAdd(mu, MatMul(Sigma, Transpose(H), Inverse(MatAdd(R, MatMul(H, Sigma, Transpose(H)))), MatAdd(MatMul(H, mu), MatMul(S.NegativeOne, data))))
+ new_Sigma = MatAdd(Sigma, MatMul(S.NegativeOne, Sigma, Transpose(H), Inverse(MatAdd(R, MatMul(H, Sigma, Transpose(H)))), H, Sigma))
+ cse_expr = cse([new_mu, new_Sigma])
+ x0 = MatrixSymbol('x0', N, N)
+ x1 = MatrixSymbol('x1', N, N)
+ replacements_expected = [
+ (x0, Transpose(H)),
+ (x1, Inverse(MatAdd(R, MatMul(H, Sigma, x0)))),
+ ]
+ reduced_exprs_expected = [
+ MatAdd(mu, MatMul(Sigma, x0, x1, MatAdd(MatMul(H, mu), MatMul(S.NegativeOne, data)))),
+ MatAdd(Sigma, MatMul(S.NegativeOne, Sigma, x0, x1, H, Sigma)),
+ ]
+ assert cse_expr == (replacements_expected, reduced_exprs_expected)
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_epathtools.py b/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_epathtools.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8bb47b2f2ff624077ab9905677b181c587ab5a7
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_epathtools.py
@@ -0,0 +1,90 @@
+"""Tests for tools for manipulation of expressions using paths. """
+
+from sympy.simplify.epathtools import epath, EPath
+from sympy.testing.pytest import raises
+
+from sympy.core.numbers import E
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.abc import x, y, z, t
+
+
+def test_epath_select():
+ expr = [((x, 1, t), 2), ((3, y, 4), z)]
+
+ assert epath("/*", expr) == [((x, 1, t), 2), ((3, y, 4), z)]
+ assert epath("/*/*", expr) == [(x, 1, t), 2, (3, y, 4), z]
+ assert epath("/*/*/*", expr) == [x, 1, t, 3, y, 4]
+ assert epath("/*/*/*/*", expr) == []
+
+ assert epath("/[:]", expr) == [((x, 1, t), 2), ((3, y, 4), z)]
+ assert epath("/[:]/[:]", expr) == [(x, 1, t), 2, (3, y, 4), z]
+ assert epath("/[:]/[:]/[:]", expr) == [x, 1, t, 3, y, 4]
+ assert epath("/[:]/[:]/[:]/[:]", expr) == []
+
+ assert epath("/*/[:]", expr) == [(x, 1, t), 2, (3, y, 4), z]
+
+ assert epath("/*/[0]", expr) == [(x, 1, t), (3, y, 4)]
+ assert epath("/*/[1]", expr) == [2, z]
+ assert epath("/*/[2]", expr) == []
+
+ assert epath("/*/int", expr) == [2]
+ assert epath("/*/Symbol", expr) == [z]
+ assert epath("/*/tuple", expr) == [(x, 1, t), (3, y, 4)]
+ assert epath("/*/__iter__?", expr) == [(x, 1, t), (3, y, 4)]
+
+ assert epath("/*/int|tuple", expr) == [(x, 1, t), 2, (3, y, 4)]
+ assert epath("/*/Symbol|tuple", expr) == [(x, 1, t), (3, y, 4), z]
+ assert epath("/*/int|Symbol|tuple", expr) == [(x, 1, t), 2, (3, y, 4), z]
+
+ assert epath("/*/int|__iter__?", expr) == [(x, 1, t), 2, (3, y, 4)]
+ assert epath("/*/Symbol|__iter__?", expr) == [(x, 1, t), (3, y, 4), z]
+ assert epath(
+ "/*/int|Symbol|__iter__?", expr) == [(x, 1, t), 2, (3, y, 4), z]
+
+ assert epath("/*/[0]/int", expr) == [1, 3, 4]
+ assert epath("/*/[0]/Symbol", expr) == [x, t, y]
+
+ assert epath("/*/[0]/int[1:]", expr) == [1, 4]
+ assert epath("/*/[0]/Symbol[1:]", expr) == [t, y]
+
+ assert epath("/Symbol", x + y + z + 1) == [x, y, z]
+ assert epath("/*/*/Symbol", t + sin(x + 1) + cos(x + y + E)) == [x, x, y]
+
+
+def test_epath_apply():
+ expr = [((x, 1, t), 2), ((3, y, 4), z)]
+ func = lambda expr: expr**2
+
+ assert epath("/*", expr, list) == [[(x, 1, t), 2], [(3, y, 4), z]]
+
+ assert epath("/*/[0]", expr, list) == [([x, 1, t], 2), ([3, y, 4], z)]
+ assert epath("/*/[1]", expr, func) == [((x, 1, t), 4), ((3, y, 4), z**2)]
+ assert epath("/*/[2]", expr, list) == expr
+
+ assert epath("/*/[0]/int", expr, func) == [((x, 1, t), 2), ((9, y, 16), z)]
+ assert epath("/*/[0]/Symbol", expr, func) == [((x**2, 1, t**2), 2),
+ ((3, y**2, 4), z)]
+ assert epath(
+ "/*/[0]/int[1:]", expr, func) == [((x, 1, t), 2), ((3, y, 16), z)]
+ assert epath("/*/[0]/Symbol[1:]", expr, func) == [((x, 1, t**2),
+ 2), ((3, y**2, 4), z)]
+
+ assert epath("/Symbol", x + y + z + 1, func) == x**2 + y**2 + z**2 + 1
+ assert epath("/*/*/Symbol", t + sin(x + 1) + cos(x + y + E), func) == \
+ t + sin(x**2 + 1) + cos(x**2 + y**2 + E)
+
+
+def test_EPath():
+ assert EPath("/*/[0]")._path == "/*/[0]"
+ assert EPath(EPath("/*/[0]"))._path == "/*/[0]"
+ assert isinstance(epath("/*/[0]"), EPath) is True
+
+ assert repr(EPath("/*/[0]")) == "EPath('/*/[0]')"
+
+ raises(ValueError, lambda: EPath(""))
+ raises(ValueError, lambda: EPath("/"))
+ raises(ValueError, lambda: EPath("/|x"))
+ raises(ValueError, lambda: EPath("/["))
+ raises(ValueError, lambda: EPath("/[0]%"))
+
+ raises(NotImplementedError, lambda: EPath("Symbol"))
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_hyperexpand.py b/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_hyperexpand.py
new file mode 100644
index 0000000000000000000000000000000000000000..c703c228a13201de13cfd4c3413fc75a2cf5bdb6
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_hyperexpand.py
@@ -0,0 +1,1063 @@
+from sympy.core.random import randrange
+
+from sympy.simplify.hyperexpand import (ShiftA, ShiftB, UnShiftA, UnShiftB,
+ MeijerShiftA, MeijerShiftB, MeijerShiftC, MeijerShiftD,
+ MeijerUnShiftA, MeijerUnShiftB, MeijerUnShiftC,
+ MeijerUnShiftD,
+ ReduceOrder, reduce_order, apply_operators,
+ devise_plan, make_derivative_operator, Formula,
+ hyperexpand, Hyper_Function, G_Function,
+ reduce_order_meijer,
+ build_hypergeometric_formula)
+from sympy.concrete.summations import Sum
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.numbers import I
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.combinatorial.factorials import binomial
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.hyper import (hyper, meijerg)
+from sympy.abc import z, a, b, c
+from sympy.testing.pytest import XFAIL, raises, slow, tooslow
+from sympy.core.random import verify_numerically as tn
+
+from sympy.core.numbers import (Rational, pi)
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.hyperbolic import atanh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (asin, cos, sin)
+from sympy.functions.special.bessel import besseli
+from sympy.functions.special.error_functions import erf
+from sympy.functions.special.gamma_functions import (gamma, lowergamma)
+
+
+def test_branch_bug():
+ assert hyperexpand(hyper((Rational(-1, 3), S.Half), (Rational(2, 3), Rational(3, 2)), -z)) == \
+ -z**S('1/3')*lowergamma(exp_polar(I*pi)/3, z)/5 \
+ + sqrt(pi)*erf(sqrt(z))/(5*sqrt(z))
+ assert hyperexpand(meijerg([Rational(7, 6), 1], [], [Rational(2, 3)], [Rational(1, 6), 0], z)) == \
+ 2*z**S('2/3')*(2*sqrt(pi)*erf(sqrt(z))/sqrt(z) - 2*lowergamma(
+ Rational(2, 3), z)/z**S('2/3'))*gamma(Rational(2, 3))/gamma(Rational(5, 3))
+
+
+def test_hyperexpand():
+ # Luke, Y. L. (1969), The Special Functions and Their Approximations,
+ # Volume 1, section 6.2
+
+ assert hyperexpand(hyper([], [], z)) == exp(z)
+ assert hyperexpand(hyper([1, 1], [2], -z)*z) == log(1 + z)
+ assert hyperexpand(hyper([], [S.Half], -z**2/4)) == cos(z)
+ assert hyperexpand(z*hyper([], [S('3/2')], -z**2/4)) == sin(z)
+ assert hyperexpand(hyper([S('1/2'), S('1/2')], [S('3/2')], z**2)*z) \
+ == asin(z)
+ assert isinstance(Sum(binomial(2, z)*z**2, (z, 0, a)).doit(), Expr)
+
+
+def can_do(ap, bq, numerical=True, div=1, lowerplane=False):
+ r = hyperexpand(hyper(ap, bq, z))
+ if r.has(hyper):
+ return False
+ if not numerical:
+ return True
+ repl = {}
+ randsyms = r.free_symbols - {z}
+ while randsyms:
+ # Only randomly generated parameters are checked.
+ for n, ai in enumerate(randsyms):
+ repl[ai] = randcplx(n)/div
+ if not any(b.is_Integer and b <= 0 for b in Tuple(*bq).subs(repl)):
+ break
+ [a, b, c, d] = [2, -1, 3, 1]
+ if lowerplane:
+ [a, b, c, d] = [2, -2, 3, -1]
+ return tn(
+ hyper(ap, bq, z).subs(repl),
+ r.replace(exp_polar, exp).subs(repl),
+ z, a=a, b=b, c=c, d=d)
+
+
+def test_roach():
+ # Kelly B. Roach. Meijer G Function Representations.
+ # Section "Gallery"
+ assert can_do([S.Half], [Rational(9, 2)])
+ assert can_do([], [1, Rational(5, 2), 4])
+ assert can_do([Rational(-1, 2), 1, 2], [3, 4])
+ assert can_do([Rational(1, 3)], [Rational(-2, 3), Rational(-1, 2), S.Half, 1])
+ assert can_do([Rational(-3, 2), Rational(-1, 2)], [Rational(-5, 2), 1])
+ assert can_do([Rational(-3, 2), ], [Rational(-1, 2), S.Half]) # shine-integral
+ assert can_do([Rational(-3, 2), Rational(-1, 2)], [2]) # elliptic integrals
+
+
+@XFAIL
+def test_roach_fail():
+ assert can_do([Rational(-1, 2), 1], [Rational(1, 4), S.Half, Rational(3, 4)]) # PFDD
+ assert can_do([Rational(3, 2)], [Rational(5, 2), 5]) # struve function
+ assert can_do([Rational(-1, 2), S.Half, 1], [Rational(3, 2), Rational(5, 2)]) # polylog, pfdd
+ assert can_do([1, 2, 3], [S.Half, 4]) # XXX ?
+ assert can_do([S.Half], [Rational(-1, 3), Rational(-1, 2), Rational(-2, 3)]) # PFDD ?
+
+# For the long table tests, see end of file
+
+
+def test_polynomial():
+ from sympy.core.numbers import oo
+ assert hyperexpand(hyper([], [-1], z)) is oo
+ assert hyperexpand(hyper([-2], [-1], z)) is oo
+ assert hyperexpand(hyper([0, 0], [-1], z)) == 1
+ assert can_do([-5, -2, randcplx(), randcplx()], [-10, randcplx()])
+ assert hyperexpand(hyper((-1, 1), (-2,), z)) == 1 + z/2
+
+
+def test_hyperexpand_bases():
+ assert hyperexpand(hyper([2], [a], z)) == \
+ a + z**(-a + 1)*(-a**2 + 3*a + z*(a - 1) - 2)*exp(z)* \
+ lowergamma(a - 1, z) - 1
+ # TODO [a+1, aRational(-1, 2)], [2*a]
+ assert hyperexpand(hyper([1, 2], [3], z)) == -2/z - 2*log(-z + 1)/z**2
+ assert hyperexpand(hyper([S.Half, 2], [Rational(3, 2)], z)) == \
+ -1/(2*z - 2) + atanh(sqrt(z))/sqrt(z)/2
+ assert hyperexpand(hyper([S.Half, S.Half], [Rational(5, 2)], z)) == \
+ (-3*z + 3)/4/(z*sqrt(-z + 1)) \
+ + (6*z - 3)*asin(sqrt(z))/(4*z**Rational(3, 2))
+ assert hyperexpand(hyper([1, 2], [Rational(3, 2)], z)) == -1/(2*z - 2) \
+ - asin(sqrt(z))/(sqrt(z)*(2*z - 2)*sqrt(-z + 1))
+ assert hyperexpand(hyper([Rational(-1, 2) - 1, 1, 2], [S.Half, 3], z)) == \
+ sqrt(z)*(z*Rational(6, 7) - Rational(6, 5))*atanh(sqrt(z)) \
+ + (-30*z**2 + 32*z - 6)/35/z - 6*log(-z + 1)/(35*z**2)
+ assert hyperexpand(hyper([1 + S.Half, 1, 1], [2, 2], z)) == \
+ -4*log(sqrt(-z + 1)/2 + S.Half)/z
+ # TODO hyperexpand(hyper([a], [2*a + 1], z))
+ # TODO [S.Half, a], [Rational(3, 2), a+1]
+ assert hyperexpand(hyper([2], [b, 1], z)) == \
+ z**(-b/2 + S.Half)*besseli(b - 1, 2*sqrt(z))*gamma(b) \
+ + z**(-b/2 + 1)*besseli(b, 2*sqrt(z))*gamma(b)
+ # TODO [a], [a - S.Half, 2*a]
+
+
+def test_hyperexpand_parametric():
+ assert hyperexpand(hyper([a, S.Half + a], [S.Half], z)) \
+ == (1 + sqrt(z))**(-2*a)/2 + (1 - sqrt(z))**(-2*a)/2
+ assert hyperexpand(hyper([a, Rational(-1, 2) + a], [2*a], z)) \
+ == 2**(2*a - 1)*((-z + 1)**S.Half + 1)**(-2*a + 1)
+
+
+def test_shifted_sum():
+ from sympy.simplify.simplify import simplify
+ assert simplify(hyperexpand(z**4*hyper([2], [3, S('3/2')], -z**2))) \
+ == z*sin(2*z) + (-z**2 + S.Half)*cos(2*z) - S.Half
+
+
+def _randrat():
+ """ Steer clear of integers. """
+ return S(randrange(25) + 10)/50
+
+
+def randcplx(offset=-1):
+ """ Polys is not good with real coefficients. """
+ return _randrat() + I*_randrat() + I*(1 + offset)
+
+
+@slow
+def test_formulae():
+ from sympy.simplify.hyperexpand import FormulaCollection
+ formulae = FormulaCollection().formulae
+ for formula in formulae:
+ h = formula.func(formula.z)
+ rep = {}
+ for n, sym in enumerate(formula.symbols):
+ rep[sym] = randcplx(n)
+
+ # NOTE hyperexpand returns truly branched functions. We know we are
+ # on the main sheet, but numerical evaluation can still go wrong
+ # (e.g. if exp_polar cannot be evalf'd).
+ # Just replace all exp_polar by exp, this usually works.
+
+ # first test if the closed-form is actually correct
+ h = h.subs(rep)
+ closed_form = formula.closed_form.subs(rep).rewrite('nonrepsmall')
+ z = formula.z
+ assert tn(h, closed_form.replace(exp_polar, exp), z)
+
+ # now test the computed matrix
+ cl = (formula.C * formula.B)[0].subs(rep).rewrite('nonrepsmall')
+ assert tn(closed_form.replace(
+ exp_polar, exp), cl.replace(exp_polar, exp), z)
+ deriv1 = z*formula.B.applyfunc(lambda t: t.rewrite(
+ 'nonrepsmall')).diff(z)
+ deriv2 = formula.M * formula.B
+ for d1, d2 in zip(deriv1, deriv2):
+ assert tn(d1.subs(rep).replace(exp_polar, exp),
+ d2.subs(rep).rewrite('nonrepsmall').replace(exp_polar, exp), z)
+
+
+def test_meijerg_formulae():
+ from sympy.simplify.hyperexpand import MeijerFormulaCollection
+ formulae = MeijerFormulaCollection().formulae
+ for sig in formulae:
+ for formula in formulae[sig]:
+ g = meijerg(formula.func.an, formula.func.ap,
+ formula.func.bm, formula.func.bq,
+ formula.z)
+ rep = {}
+ for sym in formula.symbols:
+ rep[sym] = randcplx()
+
+ # first test if the closed-form is actually correct
+ g = g.subs(rep)
+ closed_form = formula.closed_form.subs(rep)
+ z = formula.z
+ assert tn(g, closed_form, z)
+
+ # now test the computed matrix
+ cl = (formula.C * formula.B)[0].subs(rep)
+ assert tn(closed_form, cl, z)
+ deriv1 = z*formula.B.diff(z)
+ deriv2 = formula.M * formula.B
+ for d1, d2 in zip(deriv1, deriv2):
+ assert tn(d1.subs(rep), d2.subs(rep), z)
+
+
+def op(f):
+ return z*f.diff(z)
+
+
+def test_plan():
+ assert devise_plan(Hyper_Function([0], ()),
+ Hyper_Function([0], ()), z) == []
+ with raises(ValueError):
+ devise_plan(Hyper_Function([1], ()), Hyper_Function((), ()), z)
+ with raises(ValueError):
+ devise_plan(Hyper_Function([2], [1]), Hyper_Function([2], [2]), z)
+ with raises(ValueError):
+ devise_plan(Hyper_Function([2], []), Hyper_Function([S("1/2")], []), z)
+
+ # We cannot use pi/(10000 + n) because polys is insanely slow.
+ a1, a2, b1 = (randcplx(n) for n in range(3))
+ b1 += 2*I
+ h = hyper([a1, a2], [b1], z)
+
+ h2 = hyper((a1 + 1, a2), [b1], z)
+ assert tn(apply_operators(h,
+ devise_plan(Hyper_Function((a1 + 1, a2), [b1]),
+ Hyper_Function((a1, a2), [b1]), z), op),
+ h2, z)
+
+ h2 = hyper((a1 + 1, a2 - 1), [b1], z)
+ assert tn(apply_operators(h,
+ devise_plan(Hyper_Function((a1 + 1, a2 - 1), [b1]),
+ Hyper_Function((a1, a2), [b1]), z), op),
+ h2, z)
+
+
+def test_plan_derivatives():
+ a1, a2, a3 = 1, 2, S('1/2')
+ b1, b2 = 3, S('5/2')
+ h = Hyper_Function((a1, a2, a3), (b1, b2))
+ h2 = Hyper_Function((a1 + 1, a2 + 1, a3 + 2), (b1 + 1, b2 + 1))
+ ops = devise_plan(h2, h, z)
+ f = Formula(h, z, h(z), [])
+ deriv = make_derivative_operator(f.M, z)
+ assert tn((apply_operators(f.C, ops, deriv)*f.B)[0], h2(z), z)
+
+ h2 = Hyper_Function((a1, a2 - 1, a3 - 2), (b1 - 1, b2 - 1))
+ ops = devise_plan(h2, h, z)
+ assert tn((apply_operators(f.C, ops, deriv)*f.B)[0], h2(z), z)
+
+
+def test_reduction_operators():
+ a1, a2, b1 = (randcplx(n) for n in range(3))
+ h = hyper([a1], [b1], z)
+
+ assert ReduceOrder(2, 0) is None
+ assert ReduceOrder(2, -1) is None
+ assert ReduceOrder(1, S('1/2')) is None
+
+ h2 = hyper((a1, a2), (b1, a2), z)
+ assert tn(ReduceOrder(a2, a2).apply(h, op), h2, z)
+
+ h2 = hyper((a1, a2 + 1), (b1, a2), z)
+ assert tn(ReduceOrder(a2 + 1, a2).apply(h, op), h2, z)
+
+ h2 = hyper((a2 + 4, a1), (b1, a2), z)
+ assert tn(ReduceOrder(a2 + 4, a2).apply(h, op), h2, z)
+
+ # test several step order reduction
+ ap = (a2 + 4, a1, b1 + 1)
+ bq = (a2, b1, b1)
+ func, ops = reduce_order(Hyper_Function(ap, bq))
+ assert func.ap == (a1,)
+ assert func.bq == (b1,)
+ assert tn(apply_operators(h, ops, op), hyper(ap, bq, z), z)
+
+
+def test_shift_operators():
+ a1, a2, b1, b2, b3 = (randcplx(n) for n in range(5))
+ h = hyper((a1, a2), (b1, b2, b3), z)
+
+ raises(ValueError, lambda: ShiftA(0))
+ raises(ValueError, lambda: ShiftB(1))
+
+ assert tn(ShiftA(a1).apply(h, op), hyper((a1 + 1, a2), (b1, b2, b3), z), z)
+ assert tn(ShiftA(a2).apply(h, op), hyper((a1, a2 + 1), (b1, b2, b3), z), z)
+ assert tn(ShiftB(b1).apply(h, op), hyper((a1, a2), (b1 - 1, b2, b3), z), z)
+ assert tn(ShiftB(b2).apply(h, op), hyper((a1, a2), (b1, b2 - 1, b3), z), z)
+ assert tn(ShiftB(b3).apply(h, op), hyper((a1, a2), (b1, b2, b3 - 1), z), z)
+
+
+def test_ushift_operators():
+ a1, a2, b1, b2, b3 = (randcplx(n) for n in range(5))
+ h = hyper((a1, a2), (b1, b2, b3), z)
+
+ raises(ValueError, lambda: UnShiftA((1,), (), 0, z))
+ raises(ValueError, lambda: UnShiftB((), (-1,), 0, z))
+ raises(ValueError, lambda: UnShiftA((1,), (0, -1, 1), 0, z))
+ raises(ValueError, lambda: UnShiftB((0, 1), (1,), 0, z))
+
+ s = UnShiftA((a1, a2), (b1, b2, b3), 0, z)
+ assert tn(s.apply(h, op), hyper((a1 - 1, a2), (b1, b2, b3), z), z)
+ s = UnShiftA((a1, a2), (b1, b2, b3), 1, z)
+ assert tn(s.apply(h, op), hyper((a1, a2 - 1), (b1, b2, b3), z), z)
+
+ s = UnShiftB((a1, a2), (b1, b2, b3), 0, z)
+ assert tn(s.apply(h, op), hyper((a1, a2), (b1 + 1, b2, b3), z), z)
+ s = UnShiftB((a1, a2), (b1, b2, b3), 1, z)
+ assert tn(s.apply(h, op), hyper((a1, a2), (b1, b2 + 1, b3), z), z)
+ s = UnShiftB((a1, a2), (b1, b2, b3), 2, z)
+ assert tn(s.apply(h, op), hyper((a1, a2), (b1, b2, b3 + 1), z), z)
+
+
+def can_do_meijer(a1, a2, b1, b2, numeric=True):
+ """
+ This helper function tries to hyperexpand() the meijer g-function
+ corresponding to the parameters a1, a2, b1, b2.
+ It returns False if this expansion still contains g-functions.
+ If numeric is True, it also tests the so-obtained formula numerically
+ (at random values) and returns False if the test fails.
+ Else it returns True.
+ """
+ from sympy.core.function import expand
+ from sympy.functions.elementary.complexes import unpolarify
+ r = hyperexpand(meijerg(a1, a2, b1, b2, z))
+ if r.has(meijerg):
+ return False
+ # NOTE hyperexpand() returns a truly branched function, whereas numerical
+ # evaluation only works on the main branch. Since we are evaluating on
+ # the main branch, this should not be a problem, but expressions like
+ # exp_polar(I*pi/2*x)**a are evaluated incorrectly. We thus have to get
+ # rid of them. The expand heuristically does this...
+ r = unpolarify(expand(r, force=True, power_base=True, power_exp=False,
+ mul=False, log=False, multinomial=False, basic=False))
+
+ if not numeric:
+ return True
+
+ repl = {}
+ for n, ai in enumerate(meijerg(a1, a2, b1, b2, z).free_symbols - {z}):
+ repl[ai] = randcplx(n)
+ return tn(meijerg(a1, a2, b1, b2, z).subs(repl), r.subs(repl), z)
+
+
+@slow
+def test_meijerg_expand():
+ from sympy.simplify.gammasimp import gammasimp
+ from sympy.simplify.simplify import simplify
+ # from mpmath docs
+ assert hyperexpand(meijerg([[], []], [[0], []], -z)) == exp(z)
+
+ assert hyperexpand(meijerg([[1, 1], []], [[1], [0]], z)) == \
+ log(z + 1)
+ assert hyperexpand(meijerg([[1, 1], []], [[1], [1]], z)) == \
+ z/(z + 1)
+ assert hyperexpand(meijerg([[], []], [[S.Half], [0]], (z/2)**2)) \
+ == sin(z)/sqrt(pi)
+ assert hyperexpand(meijerg([[], []], [[0], [S.Half]], (z/2)**2)) \
+ == cos(z)/sqrt(pi)
+ assert can_do_meijer([], [a], [a - 1, a - S.Half], [])
+ assert can_do_meijer([], [], [a/2], [-a/2], False) # branches...
+ assert can_do_meijer([a], [b], [a], [b, a - 1])
+
+ # wikipedia
+ assert hyperexpand(meijerg([1], [], [], [0], z)) == \
+ Piecewise((0, abs(z) < 1), (1, abs(1/z) < 1),
+ (meijerg([1], [], [], [0], z), True))
+ assert hyperexpand(meijerg([], [1], [0], [], z)) == \
+ Piecewise((1, abs(z) < 1), (0, abs(1/z) < 1),
+ (meijerg([], [1], [0], [], z), True))
+
+ # The Special Functions and their Approximations
+ assert can_do_meijer([], [], [a + b/2], [a, a - b/2, a + S.Half])
+ assert can_do_meijer(
+ [], [], [a], [b], False) # branches only agree for small z
+ assert can_do_meijer([], [S.Half], [a], [-a])
+ assert can_do_meijer([], [], [a, b], [])
+ assert can_do_meijer([], [], [a, b], [])
+ assert can_do_meijer([], [], [a, a + S.Half], [b, b + S.Half])
+ assert can_do_meijer([], [], [a, -a], [0, S.Half], False) # dito
+ assert can_do_meijer([], [], [a, a + S.Half, b, b + S.Half], [])
+ assert can_do_meijer([S.Half], [], [0], [a, -a])
+ assert can_do_meijer([S.Half], [], [a], [0, -a], False) # dito
+ assert can_do_meijer([], [a - S.Half], [a, b], [a - S.Half], False)
+ assert can_do_meijer([], [a + S.Half], [a + b, a - b, a], [], False)
+ assert can_do_meijer([a + S.Half], [], [b, 2*a - b, a], [], False)
+
+ # This for example is actually zero.
+ assert can_do_meijer([], [], [], [a, b])
+
+ # Testing a bug:
+ assert hyperexpand(meijerg([0, 2], [], [], [-1, 1], z)) == \
+ Piecewise((0, abs(z) < 1),
+ (z*(1 - 1/z**2)/2, abs(1/z) < 1),
+ (meijerg([0, 2], [], [], [-1, 1], z), True))
+
+ # Test that the simplest possible answer is returned:
+ assert gammasimp(simplify(hyperexpand(
+ meijerg([1], [1 - a], [-a/2, -a/2 + S.Half], [], 1/z)))) == \
+ -2*sqrt(pi)*(sqrt(z + 1) + 1)**a/a
+
+ # Test that hyper is returned
+ assert hyperexpand(meijerg([1], [], [a], [0, 0], z)) == hyper(
+ (a,), (a + 1, a + 1), z*exp_polar(I*pi))*z**a*gamma(a)/gamma(a + 1)**2
+
+ # Test place option
+ f = meijerg(((0, 1), ()), ((S.Half,), (0,)), z**2)
+ assert hyperexpand(f) == sqrt(pi)/sqrt(1 + z**(-2))
+ assert hyperexpand(f, place=0) == sqrt(pi)*z/sqrt(z**2 + 1)
+
+
+def test_meijerg_lookup():
+ from sympy.functions.special.error_functions import (Ci, Si)
+ from sympy.functions.special.gamma_functions import uppergamma
+ assert hyperexpand(meijerg([a], [], [b, a], [], z)) == \
+ z**b*exp(z)*gamma(-a + b + 1)*uppergamma(a - b, z)
+ assert hyperexpand(meijerg([0], [], [0, 0], [], z)) == \
+ exp(z)*uppergamma(0, z)
+ assert can_do_meijer([a], [], [b, a + 1], [])
+ assert can_do_meijer([a], [], [b + 2, a], [])
+ assert can_do_meijer([a], [], [b - 2, a], [])
+
+ assert hyperexpand(meijerg([a], [], [a, a, a - S.Half], [], z)) == \
+ -sqrt(pi)*z**(a - S.Half)*(2*cos(2*sqrt(z))*(Si(2*sqrt(z)) - pi/2)
+ - 2*sin(2*sqrt(z))*Ci(2*sqrt(z))) == \
+ hyperexpand(meijerg([a], [], [a, a - S.Half, a], [], z)) == \
+ hyperexpand(meijerg([a], [], [a - S.Half, a, a], [], z))
+ assert can_do_meijer([a - 1], [], [a + 2, a - Rational(3, 2), a + 1], [])
+
+
+@XFAIL
+def test_meijerg_expand_fail():
+ # These basically test hyper([], [1/2 - a, 1/2 + 1, 1/2], z),
+ # which is *very* messy. But since the meijer g actually yields a
+ # sum of bessel functions, things can sometimes be simplified a lot and
+ # are then put into tables...
+ assert can_do_meijer([], [], [a + S.Half], [a, a - b/2, a + b/2])
+ assert can_do_meijer([], [], [0, S.Half], [a, -a])
+ assert can_do_meijer([], [], [3*a - S.Half, a, -a - S.Half], [a - S.Half])
+ assert can_do_meijer([], [], [0, a - S.Half, -a - S.Half], [S.Half])
+ assert can_do_meijer([], [], [a, b + S.Half, b], [2*b - a])
+ assert can_do_meijer([], [], [a, b + S.Half, b, 2*b - a])
+ assert can_do_meijer([S.Half], [], [-a, a], [0])
+
+
+@slow
+def test_meijerg():
+ # carefully set up the parameters.
+ # NOTE: this used to fail sometimes. I believe it is fixed, but if you
+ # hit an inexplicable test failure here, please let me know the seed.
+ a1, a2 = (randcplx(n) - 5*I - n*I for n in range(2))
+ b1, b2 = (randcplx(n) + 5*I + n*I for n in range(2))
+ b3, b4, b5, a3, a4, a5 = (randcplx() for n in range(6))
+ g = meijerg([a1], [a3, a4], [b1], [b3, b4], z)
+
+ assert ReduceOrder.meijer_minus(3, 4) is None
+ assert ReduceOrder.meijer_plus(4, 3) is None
+
+ g2 = meijerg([a1, a2], [a3, a4], [b1], [b3, b4, a2], z)
+ assert tn(ReduceOrder.meijer_plus(a2, a2).apply(g, op), g2, z)
+
+ g2 = meijerg([a1, a2], [a3, a4], [b1], [b3, b4, a2 + 1], z)
+ assert tn(ReduceOrder.meijer_plus(a2, a2 + 1).apply(g, op), g2, z)
+
+ g2 = meijerg([a1, a2 - 1], [a3, a4], [b1], [b3, b4, a2 + 2], z)
+ assert tn(ReduceOrder.meijer_plus(a2 - 1, a2 + 2).apply(g, op), g2, z)
+
+ g2 = meijerg([a1], [a3, a4, b2 - 1], [b1, b2 + 2], [b3, b4], z)
+ assert tn(ReduceOrder.meijer_minus(
+ b2 + 2, b2 - 1).apply(g, op), g2, z, tol=1e-6)
+
+ # test several-step reduction
+ an = [a1, a2]
+ bq = [b3, b4, a2 + 1]
+ ap = [a3, a4, b2 - 1]
+ bm = [b1, b2 + 1]
+ niq, ops = reduce_order_meijer(G_Function(an, ap, bm, bq))
+ assert niq.an == (a1,)
+ assert set(niq.ap) == {a3, a4}
+ assert niq.bm == (b1,)
+ assert set(niq.bq) == {b3, b4}
+ assert tn(apply_operators(g, ops, op), meijerg(an, ap, bm, bq, z), z)
+
+
+def test_meijerg_shift_operators():
+ # carefully set up the parameters. XXX this still fails sometimes
+ a1, a2, a3, a4, a5, b1, b2, b3, b4, b5 = (randcplx(n) for n in range(10))
+ g = meijerg([a1], [a3, a4], [b1], [b3, b4], z)
+
+ assert tn(MeijerShiftA(b1).apply(g, op),
+ meijerg([a1], [a3, a4], [b1 + 1], [b3, b4], z), z)
+ assert tn(MeijerShiftB(a1).apply(g, op),
+ meijerg([a1 - 1], [a3, a4], [b1], [b3, b4], z), z)
+ assert tn(MeijerShiftC(b3).apply(g, op),
+ meijerg([a1], [a3, a4], [b1], [b3 + 1, b4], z), z)
+ assert tn(MeijerShiftD(a3).apply(g, op),
+ meijerg([a1], [a3 - 1, a4], [b1], [b3, b4], z), z)
+
+ s = MeijerUnShiftA([a1], [a3, a4], [b1], [b3, b4], 0, z)
+ assert tn(
+ s.apply(g, op), meijerg([a1], [a3, a4], [b1 - 1], [b3, b4], z), z)
+
+ s = MeijerUnShiftC([a1], [a3, a4], [b1], [b3, b4], 0, z)
+ assert tn(
+ s.apply(g, op), meijerg([a1], [a3, a4], [b1], [b3 - 1, b4], z), z)
+
+ s = MeijerUnShiftB([a1], [a3, a4], [b1], [b3, b4], 0, z)
+ assert tn(
+ s.apply(g, op), meijerg([a1 + 1], [a3, a4], [b1], [b3, b4], z), z)
+
+ s = MeijerUnShiftD([a1], [a3, a4], [b1], [b3, b4], 0, z)
+ assert tn(
+ s.apply(g, op), meijerg([a1], [a3 + 1, a4], [b1], [b3, b4], z), z)
+
+
+@slow
+def test_meijerg_confluence():
+ def t(m, a, b):
+ from sympy.core.sympify import sympify
+ a, b = sympify([a, b])
+ m_ = m
+ m = hyperexpand(m)
+ if not m == Piecewise((a, abs(z) < 1), (b, abs(1/z) < 1), (m_, True)):
+ return False
+ if not (m.args[0].args[0] == a and m.args[1].args[0] == b):
+ return False
+ z0 = randcplx()/10
+ if abs(m.subs(z, z0).n() - a.subs(z, z0).n()).n() > 1e-10:
+ return False
+ if abs(m.subs(z, 1/z0).n() - b.subs(z, 1/z0).n()).n() > 1e-10:
+ return False
+ return True
+
+ assert t(meijerg([], [1, 1], [0, 0], [], z), -log(z), 0)
+ assert t(meijerg(
+ [], [3, 1], [0, 0], [], z), -z**2/4 + z - log(z)/2 - Rational(3, 4), 0)
+ assert t(meijerg([], [3, 1], [-1, 0], [], z),
+ z**2/12 - z/2 + log(z)/2 + Rational(1, 4) + 1/(6*z), 0)
+ assert t(meijerg([], [1, 1, 1, 1], [0, 0, 0, 0], [], z), -log(z)**3/6, 0)
+ assert t(meijerg([1, 1], [], [], [0, 0], z), 0, -log(1/z))
+ assert t(meijerg([1, 1], [2, 2], [1, 1], [0, 0], z),
+ -z*log(z) + 2*z, -log(1/z) + 2)
+ assert t(meijerg([S.Half], [1, 1], [0, 0], [Rational(3, 2)], z), log(z)/2 - 1, 0)
+
+ def u(an, ap, bm, bq):
+ m = meijerg(an, ap, bm, bq, z)
+ m2 = hyperexpand(m, allow_hyper=True)
+ if m2.has(meijerg) and not (m2.is_Piecewise and len(m2.args) == 3):
+ return False
+ return tn(m, m2, z)
+ assert u([], [1], [0, 0], [])
+ assert u([1, 1], [], [], [0])
+ assert u([1, 1], [2, 2, 5], [1, 1, 6], [0, 0])
+ assert u([1, 1], [2, 2, 5], [1, 1, 6], [0])
+
+
+def test_meijerg_with_Floats():
+ # see issue #10681
+ from sympy.polys.domains.realfield import RR
+ f = meijerg(((3.0, 1), ()), ((Rational(3, 2),), (0,)), z)
+ a = -2.3632718012073
+ g = a*z**Rational(3, 2)*hyper((-0.5, Rational(3, 2)), (Rational(5, 2),), z*exp_polar(I*pi))
+ assert RR.almosteq((hyperexpand(f)/g).n(), 1.0, 1e-12)
+
+
+def test_lerchphi():
+ from sympy.functions.special.zeta_functions import (lerchphi, polylog)
+ from sympy.simplify.gammasimp import gammasimp
+ assert hyperexpand(hyper([1, a], [a + 1], z)/a) == lerchphi(z, 1, a)
+ assert hyperexpand(
+ hyper([1, a, a], [a + 1, a + 1], z)/a**2) == lerchphi(z, 2, a)
+ assert hyperexpand(hyper([1, a, a, a], [a + 1, a + 1, a + 1], z)/a**3) == \
+ lerchphi(z, 3, a)
+ assert hyperexpand(hyper([1] + [a]*10, [a + 1]*10, z)/a**10) == \
+ lerchphi(z, 10, a)
+ assert gammasimp(hyperexpand(meijerg([0, 1 - a], [], [0],
+ [-a], exp_polar(-I*pi)*z))) == lerchphi(z, 1, a)
+ assert gammasimp(hyperexpand(meijerg([0, 1 - a, 1 - a], [], [0],
+ [-a, -a], exp_polar(-I*pi)*z))) == lerchphi(z, 2, a)
+ assert gammasimp(hyperexpand(meijerg([0, 1 - a, 1 - a, 1 - a], [], [0],
+ [-a, -a, -a], exp_polar(-I*pi)*z))) == lerchphi(z, 3, a)
+
+ assert hyperexpand(z*hyper([1, 1], [2], z)) == -log(1 + -z)
+ assert hyperexpand(z*hyper([1, 1, 1], [2, 2], z)) == polylog(2, z)
+ assert hyperexpand(z*hyper([1, 1, 1, 1], [2, 2, 2], z)) == polylog(3, z)
+
+ assert hyperexpand(hyper([1, a, 1 + S.Half], [a + 1, S.Half], z)) == \
+ -2*a/(z - 1) + (-2*a**2 + a)*lerchphi(z, 1, a)
+
+ # Now numerical tests. These make sure reductions etc are carried out
+ # correctly
+
+ # a rational function (polylog at negative integer order)
+ assert can_do([2, 2, 2], [1, 1])
+
+ # NOTE these contain log(1-x) etc ... better make sure we have |z| < 1
+ # reduction of order for polylog
+ assert can_do([1, 1, 1, b + 5], [2, 2, b], div=10)
+
+ # reduction of order for lerchphi
+ # XXX lerchphi in mpmath is flaky
+ assert can_do(
+ [1, a, a, a, b + 5], [a + 1, a + 1, a + 1, b], numerical=False)
+
+ # test a bug
+ from sympy.functions.elementary.complexes import Abs
+ assert hyperexpand(hyper([S.Half, S.Half, S.Half, 1],
+ [Rational(3, 2), Rational(3, 2), Rational(3, 2)], Rational(1, 4))) == \
+ Abs(-polylog(3, exp_polar(I*pi)/2) + polylog(3, S.Half))
+
+
+def test_partial_simp():
+ # First test that hypergeometric function formulae work.
+ a, b, c, d, e = (randcplx() for _ in range(5))
+ for func in [Hyper_Function([a, b, c], [d, e]),
+ Hyper_Function([], [a, b, c, d, e])]:
+ f = build_hypergeometric_formula(func)
+ z = f.z
+ assert f.closed_form == func(z)
+ deriv1 = f.B.diff(z)*z
+ deriv2 = f.M*f.B
+ for func1, func2 in zip(deriv1, deriv2):
+ assert tn(func1, func2, z)
+
+ # Now test that formulae are partially simplified.
+ a, b, z = symbols('a b z')
+ assert hyperexpand(hyper([3, a], [1, b], z)) == \
+ (-a*b/2 + a*z/2 + 2*a)*hyper([a + 1], [b], z) \
+ + (a*b/2 - 2*a + 1)*hyper([a], [b], z)
+ assert tn(
+ hyperexpand(hyper([3, d], [1, e], z)), hyper([3, d], [1, e], z), z)
+ assert hyperexpand(hyper([3], [1, a, b], z)) == \
+ hyper((), (a, b), z) \
+ + z*hyper((), (a + 1, b), z)/(2*a) \
+ - z*(b - 4)*hyper((), (a + 1, b + 1), z)/(2*a*b)
+ assert tn(
+ hyperexpand(hyper([3], [1, d, e], z)), hyper([3], [1, d, e], z), z)
+
+
+def test_hyperexpand_special():
+ assert hyperexpand(hyper([a, b], [c], 1)) == \
+ gamma(c)*gamma(c - a - b)/gamma(c - a)/gamma(c - b)
+ assert hyperexpand(hyper([a, b], [1 + a - b], -1)) == \
+ gamma(1 + a/2)*gamma(1 + a - b)/gamma(1 + a)/gamma(1 + a/2 - b)
+ assert hyperexpand(hyper([a, b], [1 + b - a], -1)) == \
+ gamma(1 + b/2)*gamma(1 + b - a)/gamma(1 + b)/gamma(1 + b/2 - a)
+ assert hyperexpand(meijerg([1 - z - a/2], [1 - z + a/2], [b/2], [-b/2], 1)) == \
+ gamma(1 - 2*z)*gamma(z + a/2 + b/2)/gamma(1 - z + a/2 - b/2) \
+ /gamma(1 - z - a/2 + b/2)/gamma(1 - z + a/2 + b/2)
+ assert hyperexpand(hyper([a], [b], 0)) == 1
+ assert hyper([a], [b], 0) != 0
+
+
+def test_Mod1_behavior():
+ from sympy.core.symbol import Symbol
+ from sympy.simplify.simplify import simplify
+ n = Symbol('n', integer=True)
+ # Note: this should not hang.
+ assert simplify(hyperexpand(meijerg([1], [], [n + 1], [0], z))) == \
+ lowergamma(n + 1, z)
+
+
+@slow
+def test_prudnikov_misc():
+ assert can_do([1, (3 + I)/2, (3 - I)/2], [Rational(3, 2), 2])
+ assert can_do([S.Half, a - 1], [Rational(3, 2), a + 1], lowerplane=True)
+ assert can_do([], [b + 1])
+ assert can_do([a], [a - 1, b + 1])
+
+ assert can_do([a], [a - S.Half, 2*a])
+ assert can_do([a], [a - S.Half, 2*a + 1])
+ assert can_do([a], [a - S.Half, 2*a - 1])
+ assert can_do([a], [a + S.Half, 2*a])
+ assert can_do([a], [a + S.Half, 2*a + 1])
+ assert can_do([a], [a + S.Half, 2*a - 1])
+ assert can_do([S.Half], [b, 2 - b])
+ assert can_do([S.Half], [b, 3 - b])
+ assert can_do([1], [2, b])
+
+ assert can_do([a, a + S.Half], [2*a, b, 2*a - b + 1])
+ assert can_do([a, a + S.Half], [S.Half, 2*a, 2*a + S.Half])
+ assert can_do([a], [a + 1], lowerplane=True) # lowergamma
+
+
+def test_prudnikov_1():
+ # A. P. Prudnikov, Yu. A. Brychkov and O. I. Marichev (1990).
+ # Integrals and Series: More Special Functions, Vol. 3,.
+ # Gordon and Breach Science Publisher
+
+ # 7.3.1
+ assert can_do([a, -a], [S.Half])
+ assert can_do([a, 1 - a], [S.Half])
+ assert can_do([a, 1 - a], [Rational(3, 2)])
+ assert can_do([a, 2 - a], [S.Half])
+ assert can_do([a, 2 - a], [Rational(3, 2)])
+ assert can_do([a, 2 - a], [Rational(3, 2)])
+ assert can_do([a, a + S.Half], [2*a - 1])
+ assert can_do([a, a + S.Half], [2*a])
+ assert can_do([a, a + S.Half], [2*a + 1])
+ assert can_do([a, a + S.Half], [S.Half])
+ assert can_do([a, a + S.Half], [Rational(3, 2)])
+ assert can_do([a, a/2 + 1], [a/2])
+ assert can_do([1, b], [2])
+ assert can_do([1, b], [b + 1], numerical=False) # Lerch Phi
+ # NOTE: branches are complicated for |z| > 1
+
+ assert can_do([a], [2*a])
+ assert can_do([a], [2*a + 1])
+ assert can_do([a], [2*a - 1])
+
+
+@slow
+def test_prudnikov_2():
+ h = S.Half
+ assert can_do([-h, -h], [h])
+ assert can_do([-h, h], [3*h])
+ assert can_do([-h, h], [5*h])
+ assert can_do([-h, h], [7*h])
+ assert can_do([-h, 1], [h])
+
+ for p in [-h, h]:
+ for n in [-h, h, 1, 3*h, 2, 5*h, 3, 7*h, 4]:
+ for m in [-h, h, 3*h, 5*h, 7*h]:
+ assert can_do([p, n], [m])
+ for n in [1, 2, 3, 4]:
+ for m in [1, 2, 3, 4]:
+ assert can_do([p, n], [m])
+
+
+def test_prudnikov_3():
+ h = S.Half
+ assert can_do([Rational(1, 4), Rational(3, 4)], [h])
+ assert can_do([Rational(1, 4), Rational(3, 4)], [3*h])
+ assert can_do([Rational(1, 3), Rational(2, 3)], [3*h])
+ assert can_do([Rational(3, 4), Rational(5, 4)], [h])
+ assert can_do([Rational(3, 4), Rational(5, 4)], [3*h])
+
+
+@tooslow
+def test_prudnikov_3_slow():
+ # XXX: This is marked as tooslow and hence skipped in CI. None of the
+ # individual cases below fails or hangs. Some cases are slow and the loops
+ # below generate 280 different cases. Is it really necessary to test all
+ # 280 cases here?
+ h = S.Half
+ for p in [1, 2, 3, 4]:
+ for n in [-h, h, 1, 3*h, 2, 5*h, 3, 7*h, 4, 9*h]:
+ for m in [1, 3*h, 2, 5*h, 3, 7*h, 4]:
+ assert can_do([p, m], [n])
+
+
+@slow
+def test_prudnikov_4():
+ h = S.Half
+ for p in [3*h, 5*h, 7*h]:
+ for n in [-h, h, 3*h, 5*h, 7*h]:
+ for m in [3*h, 2, 5*h, 3, 7*h, 4]:
+ assert can_do([p, m], [n])
+ for n in [1, 2, 3, 4]:
+ for m in [2, 3, 4]:
+ assert can_do([p, m], [n])
+
+
+@slow
+def test_prudnikov_5():
+ h = S.Half
+
+ for p in [1, 2, 3]:
+ for q in range(p, 4):
+ for r in [1, 2, 3]:
+ for s in range(r, 4):
+ assert can_do([-h, p, q], [r, s])
+
+ for p in [h, 1, 3*h, 2, 5*h, 3]:
+ for q in [h, 3*h, 5*h]:
+ for r in [h, 3*h, 5*h]:
+ for s in [h, 3*h, 5*h]:
+ if s <= q and s <= r:
+ assert can_do([-h, p, q], [r, s])
+
+ for p in [h, 1, 3*h, 2, 5*h, 3]:
+ for q in [1, 2, 3]:
+ for r in [h, 3*h, 5*h]:
+ for s in [1, 2, 3]:
+ assert can_do([-h, p, q], [r, s])
+
+
+@slow
+def test_prudnikov_6():
+ h = S.Half
+
+ for m in [3*h, 5*h]:
+ for n in [1, 2, 3]:
+ for q in [h, 1, 2]:
+ for p in [1, 2, 3]:
+ assert can_do([h, q, p], [m, n])
+ for q in [1, 2, 3]:
+ for p in [3*h, 5*h]:
+ assert can_do([h, q, p], [m, n])
+
+ for q in [1, 2]:
+ for p in [1, 2, 3]:
+ for m in [1, 2, 3]:
+ for n in [1, 2, 3]:
+ assert can_do([h, q, p], [m, n])
+
+ assert can_do([h, h, 5*h], [3*h, 3*h])
+ assert can_do([h, 1, 5*h], [3*h, 3*h])
+ assert can_do([h, 2, 2], [1, 3])
+
+ # pages 435 to 457 contain more PFDD and stuff like this
+
+
+@slow
+def test_prudnikov_7():
+ assert can_do([3], [6])
+
+ h = S.Half
+ for n in [h, 3*h, 5*h, 7*h]:
+ assert can_do([-h], [n])
+ for m in [-h, h, 1, 3*h, 2, 5*h, 3, 7*h, 4]: # HERE
+ for n in [-h, h, 3*h, 5*h, 7*h, 1, 2, 3, 4]:
+ assert can_do([m], [n])
+
+
+@slow
+def test_prudnikov_8():
+ h = S.Half
+
+ # 7.12.2
+ for ai in [1, 2, 3]:
+ for bi in [1, 2, 3]:
+ for ci in range(1, ai + 1):
+ for di in [h, 1, 3*h, 2, 5*h, 3]:
+ assert can_do([ai, bi], [ci, di])
+ for bi in [3*h, 5*h]:
+ for ci in [h, 1, 3*h, 2, 5*h, 3]:
+ for di in [1, 2, 3]:
+ assert can_do([ai, bi], [ci, di])
+
+ for ai in [-h, h, 3*h, 5*h]:
+ for bi in [1, 2, 3]:
+ for ci in [h, 1, 3*h, 2, 5*h, 3]:
+ for di in [1, 2, 3]:
+ assert can_do([ai, bi], [ci, di])
+ for bi in [h, 3*h, 5*h]:
+ for ci in [h, 3*h, 5*h, 3]:
+ for di in [h, 1, 3*h, 2, 5*h, 3]:
+ if ci <= bi:
+ assert can_do([ai, bi], [ci, di])
+
+
+def test_prudnikov_9():
+ # 7.13.1 [we have a general formula ... so this is a bit pointless]
+ for i in range(9):
+ assert can_do([], [(S(i) + 1)/2])
+ for i in range(5):
+ assert can_do([], [-(2*S(i) + 1)/2])
+
+
+@slow
+def test_prudnikov_10():
+ # 7.14.2
+ h = S.Half
+ for p in [-h, h, 1, 3*h, 2, 5*h, 3, 7*h, 4]:
+ for m in [1, 2, 3, 4]:
+ for n in range(m, 5):
+ assert can_do([p], [m, n])
+
+ for p in [1, 2, 3, 4]:
+ for n in [h, 3*h, 5*h, 7*h]:
+ for m in [1, 2, 3, 4]:
+ assert can_do([p], [n, m])
+
+ for p in [3*h, 5*h, 7*h]:
+ for m in [h, 1, 2, 5*h, 3, 7*h, 4]:
+ assert can_do([p], [h, m])
+ assert can_do([p], [3*h, m])
+
+ for m in [h, 1, 2, 5*h, 3, 7*h, 4]:
+ assert can_do([7*h], [5*h, m])
+
+ assert can_do([Rational(-1, 2)], [S.Half, S.Half]) # shine-integral shi
+
+
+def test_prudnikov_11():
+ # 7.15
+ assert can_do([a, a + S.Half], [2*a, b, 2*a - b])
+ assert can_do([a, a + S.Half], [Rational(3, 2), 2*a, 2*a - S.Half])
+
+ assert can_do([Rational(1, 4), Rational(3, 4)], [S.Half, S.Half, 1])
+ assert can_do([Rational(5, 4), Rational(3, 4)], [Rational(3, 2), S.Half, 2])
+ assert can_do([Rational(5, 4), Rational(3, 4)], [Rational(3, 2), Rational(3, 2), 1])
+ assert can_do([Rational(5, 4), Rational(7, 4)], [Rational(3, 2), Rational(5, 2), 2])
+
+ assert can_do([1, 1], [Rational(3, 2), 2, 2]) # cosh-integral chi
+
+
+def test_prudnikov_12():
+ # 7.16
+ assert can_do(
+ [], [a, a + S.Half, 2*a], False) # branches only agree for some z!
+ assert can_do([], [a, a + S.Half, 2*a + 1], False) # dito
+ assert can_do([], [S.Half, a, a + S.Half])
+ assert can_do([], [Rational(3, 2), a, a + S.Half])
+
+ assert can_do([], [Rational(1, 4), S.Half, Rational(3, 4)])
+ assert can_do([], [S.Half, S.Half, 1])
+ assert can_do([], [S.Half, Rational(3, 2), 1])
+ assert can_do([], [Rational(3, 4), Rational(3, 2), Rational(5, 4)])
+ assert can_do([], [1, 1, Rational(3, 2)])
+ assert can_do([], [1, 2, Rational(3, 2)])
+ assert can_do([], [1, Rational(3, 2), Rational(3, 2)])
+ assert can_do([], [Rational(5, 4), Rational(3, 2), Rational(7, 4)])
+ assert can_do([], [2, Rational(3, 2), Rational(3, 2)])
+
+
+@slow
+def test_prudnikov_2F1():
+ h = S.Half
+ # Elliptic integrals
+ for p in [-h, h]:
+ for m in [h, 3*h, 5*h, 7*h]:
+ for n in [1, 2, 3, 4]:
+ assert can_do([p, m], [n])
+
+
+@XFAIL
+def test_prudnikov_fail_2F1():
+ assert can_do([a, b], [b + 1]) # incomplete beta function
+ assert can_do([-1, b], [c]) # Poly. also -2, -3 etc
+
+ # TODO polys
+
+ # Legendre functions:
+ assert can_do([a, b], [a + b + S.Half])
+ assert can_do([a, b], [a + b - S.Half])
+ assert can_do([a, b], [a + b + Rational(3, 2)])
+ assert can_do([a, b], [(a + b + 1)/2])
+ assert can_do([a, b], [(a + b)/2 + 1])
+ assert can_do([a, b], [a - b + 1])
+ assert can_do([a, b], [a - b + 2])
+ assert can_do([a, b], [2*b])
+ assert can_do([a, b], [S.Half])
+ assert can_do([a, b], [Rational(3, 2)])
+ assert can_do([a, 1 - a], [c])
+ assert can_do([a, 2 - a], [c])
+ assert can_do([a, 3 - a], [c])
+ assert can_do([a, a + S.Half], [c])
+ assert can_do([1, b], [c])
+ assert can_do([1, b], [Rational(3, 2)])
+
+ assert can_do([Rational(1, 4), Rational(3, 4)], [1])
+
+ # PFDD
+ o = S.One
+ assert can_do([o/8, 1], [o/8*9])
+ assert can_do([o/6, 1], [o/6*7])
+ assert can_do([o/6, 1], [o/6*13])
+ assert can_do([o/5, 1], [o/5*6])
+ assert can_do([o/5, 1], [o/5*11])
+ assert can_do([o/4, 1], [o/4*5])
+ assert can_do([o/4, 1], [o/4*9])
+ assert can_do([o/3, 1], [o/3*4])
+ assert can_do([o/3, 1], [o/3*7])
+ assert can_do([o/8*3, 1], [o/8*11])
+ assert can_do([o/5*2, 1], [o/5*7])
+ assert can_do([o/5*2, 1], [o/5*12])
+ assert can_do([o/5*3, 1], [o/5*8])
+ assert can_do([o/5*3, 1], [o/5*13])
+ assert can_do([o/8*5, 1], [o/8*13])
+ assert can_do([o/4*3, 1], [o/4*7])
+ assert can_do([o/4*3, 1], [o/4*11])
+ assert can_do([o/3*2, 1], [o/3*5])
+ assert can_do([o/3*2, 1], [o/3*8])
+ assert can_do([o/5*4, 1], [o/5*9])
+ assert can_do([o/5*4, 1], [o/5*14])
+ assert can_do([o/6*5, 1], [o/6*11])
+ assert can_do([o/6*5, 1], [o/6*17])
+ assert can_do([o/8*7, 1], [o/8*15])
+
+
+@XFAIL
+def test_prudnikov_fail_3F2():
+ assert can_do([a, a + Rational(1, 3), a + Rational(2, 3)], [Rational(1, 3), Rational(2, 3)])
+ assert can_do([a, a + Rational(1, 3), a + Rational(2, 3)], [Rational(2, 3), Rational(4, 3)])
+ assert can_do([a, a + Rational(1, 3), a + Rational(2, 3)], [Rational(4, 3), Rational(5, 3)])
+
+ # page 421
+ assert can_do([a, a + Rational(1, 3), a + Rational(2, 3)], [a*Rational(3, 2), (3*a + 1)/2])
+
+ # pages 422 ...
+ assert can_do([Rational(-1, 2), S.Half, S.Half], [1, 1]) # elliptic integrals
+ assert can_do([Rational(-1, 2), S.Half, 1], [Rational(3, 2), Rational(3, 2)])
+ # TODO LOTS more
+
+ # PFDD
+ assert can_do([Rational(1, 8), Rational(3, 8), 1], [Rational(9, 8), Rational(11, 8)])
+ assert can_do([Rational(1, 8), Rational(5, 8), 1], [Rational(9, 8), Rational(13, 8)])
+ assert can_do([Rational(1, 8), Rational(7, 8), 1], [Rational(9, 8), Rational(15, 8)])
+ assert can_do([Rational(1, 6), Rational(1, 3), 1], [Rational(7, 6), Rational(4, 3)])
+ assert can_do([Rational(1, 6), Rational(2, 3), 1], [Rational(7, 6), Rational(5, 3)])
+ assert can_do([Rational(1, 6), Rational(2, 3), 1], [Rational(5, 3), Rational(13, 6)])
+ assert can_do([S.Half, 1, 1], [Rational(1, 4), Rational(3, 4)])
+ # LOTS more
+
+
+@XFAIL
+def test_prudnikov_fail_other():
+ # 7.11.2
+
+ # 7.12.1
+ assert can_do([1, a], [b, 1 - 2*a + b]) # ???
+
+ # 7.14.2
+ assert can_do([Rational(-1, 2)], [S.Half, 1]) # struve
+ assert can_do([1], [S.Half, S.Half]) # struve
+ assert can_do([Rational(1, 4)], [S.Half, Rational(5, 4)]) # PFDD
+ assert can_do([Rational(3, 4)], [Rational(3, 2), Rational(7, 4)]) # PFDD
+ assert can_do([1], [Rational(1, 4), Rational(3, 4)]) # PFDD
+ assert can_do([1], [Rational(3, 4), Rational(5, 4)]) # PFDD
+ assert can_do([1], [Rational(5, 4), Rational(7, 4)]) # PFDD
+ # TODO LOTS more
+
+ # 7.15.2
+ assert can_do([S.Half, 1], [Rational(3, 4), Rational(5, 4), Rational(3, 2)]) # PFDD
+ assert can_do([S.Half, 1], [Rational(7, 4), Rational(5, 4), Rational(3, 2)]) # PFDD
+
+ # 7.16.1
+ assert can_do([], [Rational(1, 3), S(2/3)]) # PFDD
+ assert can_do([], [Rational(2, 3), S(4/3)]) # PFDD
+ assert can_do([], [Rational(5, 3), S(4/3)]) # PFDD
+
+ # XXX this does not *evaluate* right??
+ assert can_do([], [a, a + S.Half, 2*a - 1])
+
+
+def test_bug():
+ h = hyper([-1, 1], [z], -1)
+ assert hyperexpand(h) == (z + 1)/z
+
+
+def test_omgissue_203():
+ h = hyper((-5, -3, -4), (-6, -6), 1)
+ assert hyperexpand(h) == Rational(1, 30)
+ h = hyper((-6, -7, -5), (-6, -6), 1)
+ assert hyperexpand(h) == Rational(-1, 6)
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_radsimp.py b/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_radsimp.py
new file mode 100644
index 0000000000000000000000000000000000000000..fabea1f1acb63c1e7845e82bcfd2a41c6bf97e67
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_radsimp.py
@@ -0,0 +1,490 @@
+from sympy.core.add import Add
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, Wild, symbols)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.polys.polytools import factor
+from sympy.series.order import O
+from sympy.simplify.radsimp import (collect, collect_const, fraction, radsimp, rcollect)
+
+from sympy.core.expr import unchanged
+from sympy.core.mul import _unevaluated_Mul as umul
+from sympy.simplify.radsimp import (_unevaluated_Add,
+ collect_sqrt, fraction_expand, collect_abs)
+from sympy.testing.pytest import raises
+
+from sympy.abc import x, y, z, a, b, c, d
+
+
+def test_radsimp():
+ r2 = sqrt(2)
+ r3 = sqrt(3)
+ r5 = sqrt(5)
+ r7 = sqrt(7)
+ assert fraction(radsimp(1/r2)) == (sqrt(2), 2)
+ assert radsimp(1/(1 + r2)) == \
+ -1 + sqrt(2)
+ assert radsimp(1/(r2 + r3)) == \
+ -sqrt(2) + sqrt(3)
+ assert fraction(radsimp(1/(1 + r2 + r3))) == \
+ (-sqrt(6) + sqrt(2) + 2, 4)
+ assert fraction(radsimp(1/(r2 + r3 + r5))) == \
+ (-sqrt(30) + 2*sqrt(3) + 3*sqrt(2), 12)
+ assert fraction(radsimp(1/(1 + r2 + r3 + r5))) == (
+ (-34*sqrt(10) - 26*sqrt(15) - 55*sqrt(3) - 61*sqrt(2) + 14*sqrt(30) +
+ 93 + 46*sqrt(6) + 53*sqrt(5), 71))
+ assert fraction(radsimp(1/(r2 + r3 + r5 + r7))) == (
+ (-50*sqrt(42) - 133*sqrt(5) - 34*sqrt(70) - 145*sqrt(3) + 22*sqrt(105)
+ + 185*sqrt(2) + 62*sqrt(30) + 135*sqrt(7), 215))
+ z = radsimp(1/(1 + r2/3 + r3/5 + r5 + r7))
+ assert len((3616791619821680643598*z).args) == 16
+ assert radsimp(1/z) == 1/z
+ assert radsimp(1/z, max_terms=20).expand() == 1 + r2/3 + r3/5 + r5 + r7
+ assert radsimp(1/(r2*3)) == \
+ sqrt(2)/6
+ assert radsimp(1/(r2*a + r3 + r5 + r7)) == (
+ (8*sqrt(2)*a**7 - 8*sqrt(7)*a**6 - 8*sqrt(5)*a**6 - 8*sqrt(3)*a**6 -
+ 180*sqrt(2)*a**5 + 8*sqrt(30)*a**5 + 8*sqrt(42)*a**5 + 8*sqrt(70)*a**5
+ - 24*sqrt(105)*a**4 + 84*sqrt(3)*a**4 + 100*sqrt(5)*a**4 +
+ 116*sqrt(7)*a**4 - 72*sqrt(70)*a**3 - 40*sqrt(42)*a**3 -
+ 8*sqrt(30)*a**3 + 782*sqrt(2)*a**3 - 462*sqrt(3)*a**2 -
+ 302*sqrt(7)*a**2 - 254*sqrt(5)*a**2 + 120*sqrt(105)*a**2 -
+ 795*sqrt(2)*a - 62*sqrt(30)*a + 82*sqrt(42)*a + 98*sqrt(70)*a -
+ 118*sqrt(105) + 59*sqrt(7) + 295*sqrt(5) + 531*sqrt(3))/(16*a**8 -
+ 480*a**6 + 3128*a**4 - 6360*a**2 + 3481))
+ assert radsimp(1/(r2*a + r2*b + r3 + r7)) == (
+ (sqrt(2)*a*(a + b)**2 - 5*sqrt(2)*a + sqrt(42)*a + sqrt(2)*b*(a +
+ b)**2 - 5*sqrt(2)*b + sqrt(42)*b - sqrt(7)*(a + b)**2 - sqrt(3)*(a +
+ b)**2 - 2*sqrt(3) + 2*sqrt(7))/(2*a**4 + 8*a**3*b + 12*a**2*b**2 -
+ 20*a**2 + 8*a*b**3 - 40*a*b + 2*b**4 - 20*b**2 + 8))
+ assert radsimp(1/(r2*a + r2*b + r2*c + r2*d)) == \
+ sqrt(2)/(2*a + 2*b + 2*c + 2*d)
+ assert radsimp(1/(1 + r2*a + r2*b + r2*c + r2*d)) == (
+ (sqrt(2)*a + sqrt(2)*b + sqrt(2)*c + sqrt(2)*d - 1)/(2*a**2 + 4*a*b +
+ 4*a*c + 4*a*d + 2*b**2 + 4*b*c + 4*b*d + 2*c**2 + 4*c*d + 2*d**2 - 1))
+ assert radsimp((y**2 - x)/(y - sqrt(x))) == \
+ sqrt(x) + y
+ assert radsimp(-(y**2 - x)/(y - sqrt(x))) == \
+ -(sqrt(x) + y)
+ assert radsimp(1/(1 - I + a*I)) == \
+ (-I*a + 1 + I)/(a**2 - 2*a + 2)
+ assert radsimp(1/((-x + y)*(x - sqrt(y)))) == \
+ (-x - sqrt(y))/((x - y)*(x**2 - y))
+ e = (3 + 3*sqrt(2))*x*(3*x - 3*sqrt(y))
+ assert radsimp(e) == x*(3 + 3*sqrt(2))*(3*x - 3*sqrt(y))
+ assert radsimp(1/e) == (
+ (-9*x + 9*sqrt(2)*x - 9*sqrt(y) + 9*sqrt(2)*sqrt(y))/(9*x*(9*x**2 -
+ 9*y)))
+ assert radsimp(1 + 1/(1 + sqrt(3))) == \
+ Mul(S.Half, -1 + sqrt(3), evaluate=False) + 1
+ A = symbols("A", commutative=False)
+ assert radsimp(x**2 + sqrt(2)*x**2 - sqrt(2)*x*A) == \
+ x**2 + sqrt(2)*x**2 - sqrt(2)*x*A
+ assert radsimp(1/sqrt(5 + 2 * sqrt(6))) == -sqrt(2) + sqrt(3)
+ assert radsimp(1/sqrt(5 + 2 * sqrt(6))**3) == -(-sqrt(3) + sqrt(2))**3
+
+ # issue 6532
+ assert fraction(radsimp(1/sqrt(x))) == (sqrt(x), x)
+ assert fraction(radsimp(1/sqrt(2*x + 3))) == (sqrt(2*x + 3), 2*x + 3)
+ assert fraction(radsimp(1/sqrt(2*(x + 3)))) == (sqrt(2*x + 6), 2*x + 6)
+
+ # issue 5994
+ e = S('-(2 + 2*sqrt(2) + 4*2**(1/4))/'
+ '(1 + 2**(3/4) + 3*2**(1/4) + 3*sqrt(2))')
+ assert radsimp(e).expand() == -2*2**Rational(3, 4) - 2*2**Rational(1, 4) + 2 + 2*sqrt(2)
+
+ # issue 5986 (modifications to radimp didn't initially recognize this so
+ # the test is included here)
+ assert radsimp(1/(-sqrt(5)/2 - S.Half + (-sqrt(5)/2 - S.Half)**2)) == 1
+
+ # from issue 5934
+ eq = (
+ (-240*sqrt(2)*sqrt(sqrt(5) + 5)*sqrt(8*sqrt(5) + 40) -
+ 360*sqrt(2)*sqrt(-8*sqrt(5) + 40)*sqrt(-sqrt(5) + 5) -
+ 120*sqrt(10)*sqrt(-8*sqrt(5) + 40)*sqrt(-sqrt(5) + 5) +
+ 120*sqrt(2)*sqrt(-sqrt(5) + 5)*sqrt(8*sqrt(5) + 40) +
+ 120*sqrt(2)*sqrt(-8*sqrt(5) + 40)*sqrt(sqrt(5) + 5) +
+ 120*sqrt(10)*sqrt(-sqrt(5) + 5)*sqrt(8*sqrt(5) + 40) +
+ 120*sqrt(10)*sqrt(-8*sqrt(5) + 40)*sqrt(sqrt(5) + 5))/(-36000 -
+ 7200*sqrt(5) + (12*sqrt(10)*sqrt(sqrt(5) + 5) +
+ 24*sqrt(10)*sqrt(-sqrt(5) + 5))**2))
+ assert radsimp(eq) is S.NaN # it's 0/0
+
+ # work with normal form
+ e = 1/sqrt(sqrt(7)/7 + 2*sqrt(2) + 3*sqrt(3) + 5*sqrt(5)) + 3
+ assert radsimp(e) == (
+ -sqrt(sqrt(7) + 14*sqrt(2) + 21*sqrt(3) +
+ 35*sqrt(5))*(-11654899*sqrt(35) - 1577436*sqrt(210) - 1278438*sqrt(15)
+ - 1346996*sqrt(10) + 1635060*sqrt(6) + 5709765 + 7539830*sqrt(14) +
+ 8291415*sqrt(21))/1300423175 + 3)
+
+ # obey power rules
+ base = sqrt(3) - sqrt(2)
+ assert radsimp(1/base**3) == (sqrt(3) + sqrt(2))**3
+ assert radsimp(1/(-base)**3) == -(sqrt(2) + sqrt(3))**3
+ assert radsimp(1/(-base)**x) == (-base)**(-x)
+ assert radsimp(1/base**x) == (sqrt(2) + sqrt(3))**x
+ assert radsimp(root(1/(-1 - sqrt(2)), -x)) == (-1)**(-1/x)*(1 + sqrt(2))**(1/x)
+
+ # recurse
+ e = cos(1/(1 + sqrt(2)))
+ assert radsimp(e) == cos(-sqrt(2) + 1)
+ assert radsimp(e/2) == cos(-sqrt(2) + 1)/2
+ assert radsimp(1/e) == 1/cos(-sqrt(2) + 1)
+ assert radsimp(2/e) == 2/cos(-sqrt(2) + 1)
+ assert fraction(radsimp(e/sqrt(x))) == (sqrt(x)*cos(-sqrt(2)+1), x)
+
+ # test that symbolic denominators are not processed
+ r = 1 + sqrt(2)
+ assert radsimp(x/r, symbolic=False) == -x*(-sqrt(2) + 1)
+ assert radsimp(x/(y + r), symbolic=False) == x/(y + 1 + sqrt(2))
+ assert radsimp(x/(y + r)/r, symbolic=False) == \
+ -x*(-sqrt(2) + 1)/(y + 1 + sqrt(2))
+
+ # issue 7408
+ eq = sqrt(x)/sqrt(y)
+ assert radsimp(eq) == umul(sqrt(x), sqrt(y), 1/y)
+ assert radsimp(eq, symbolic=False) == eq
+
+ # issue 7498
+ assert radsimp(sqrt(x)/sqrt(y)**3) == umul(sqrt(x), sqrt(y**3), 1/y**3)
+
+ # for coverage
+ eq = sqrt(x)/y**2
+ assert radsimp(eq) == eq
+
+
+def test_radsimp_issue_3214():
+ c, p = symbols('c p', positive=True)
+ s = sqrt(c**2 - p**2)
+ b = (c + I*p - s)/(c + I*p + s)
+ assert radsimp(b) == -I*(c + I*p - sqrt(c**2 - p**2))**2/(2*c*p)
+
+
+def test_collect_1():
+ """Collect with respect to Symbol"""
+ x, y, z, n = symbols('x,y,z,n')
+ assert collect(1, x) == 1
+ assert collect( x + y*x, x ) == x * (1 + y)
+ assert collect( x + x**2, x ) == x + x**2
+ assert collect( x**2 + y*x**2, x ) == (x**2)*(1 + y)
+ assert collect( x**2 + y*x, x ) == x*y + x**2
+ assert collect( 2*x**2 + y*x**2 + 3*x*y, [x] ) == x**2*(2 + y) + 3*x*y
+ assert collect( 2*x**2 + y*x**2 + 3*x*y, [y] ) == 2*x**2 + y*(x**2 + 3*x)
+
+ assert collect( ((1 + y + x)**4).expand(), x) == ((1 + y)**4).expand() + \
+ x*(4*(1 + y)**3).expand() + x**2*(6*(1 + y)**2).expand() + \
+ x**3*(4*(1 + y)).expand() + x**4
+ # symbols can be given as any iterable
+ expr = x + y
+ assert collect(expr, expr.free_symbols) == expr
+ assert collect(x*exp(x) + sin(x)*y + sin(x)*2 + 3*x, x, exact=None
+ ) == x*exp(x) + 3*x + (y + 2)*sin(x)
+ assert collect(x*exp(x) + sin(x)*y + sin(x)*2 + 3*x + y*x +
+ y*x*exp(x), x, exact=None
+ ) == x*exp(x)*(y + 1) + (3 + y)*x + (y + 2)*sin(x)
+
+
+def test_collect_2():
+ """Collect with respect to a sum"""
+ a, b, x = symbols('a,b,x')
+ assert collect(a*(cos(x) + sin(x)) + b*(cos(x) + sin(x)),
+ sin(x) + cos(x)) == (a + b)*(cos(x) + sin(x))
+
+
+def test_collect_3():
+ """Collect with respect to a product"""
+ a, b, c = symbols('a,b,c')
+ f = Function('f')
+ x, y, z, n = symbols('x,y,z,n')
+
+ assert collect(-x/8 + x*y, -x) == x*(y - Rational(1, 8))
+
+ assert collect( 1 + x*(y**2), x*y ) == 1 + x*(y**2)
+ assert collect( x*y + a*x*y, x*y) == x*y*(1 + a)
+ assert collect( 1 + x*y + a*x*y, x*y) == 1 + x*y*(1 + a)
+ assert collect(a*x*f(x) + b*(x*f(x)), x*f(x)) == x*(a + b)*f(x)
+
+ assert collect(a*x*log(x) + b*(x*log(x)), x*log(x)) == x*(a + b)*log(x)
+ assert collect(a*x**2*log(x)**2 + b*(x*log(x))**2, x*log(x)) == \
+ x**2*log(x)**2*(a + b)
+
+ # with respect to a product of three symbols
+ assert collect(y*x*z + a*x*y*z, x*y*z) == (1 + a)*x*y*z
+
+
+def test_collect_4():
+ """Collect with respect to a power"""
+ a, b, c, x = symbols('a,b,c,x')
+
+ assert collect(a*x**c + b*x**c, x**c) == x**c*(a + b)
+ # issue 6096: 2 stays with c (unless c is integer or x is positive0
+ assert collect(a*x**(2*c) + b*x**(2*c), x**c) == x**(2*c)*(a + b)
+
+
+def test_collect_5():
+ """Collect with respect to a tuple"""
+ a, x, y, z, n = symbols('a,x,y,z,n')
+ assert collect(x**2*y**4 + z*(x*y**2)**2 + z + a*z, [x*y**2, z]) in [
+ z*(1 + a + x**2*y**4) + x**2*y**4,
+ z*(1 + a) + x**2*y**4*(1 + z) ]
+ assert collect((1 + (x + y) + (x + y)**2).expand(),
+ [x, y]) == 1 + y + x*(1 + 2*y) + x**2 + y**2
+
+
+def test_collect_pr19431():
+ """Unevaluated collect with respect to a product"""
+ a = symbols('a')
+ assert collect(a**2*(a**2 + 1), a**2, evaluate=False)[a**2] == (a**2 + 1)
+
+
+def test_collect_D():
+ D = Derivative
+ f = Function('f')
+ x, a, b = symbols('x,a,b')
+ fx = D(f(x), x)
+ fxx = D(f(x), x, x)
+
+ assert collect(a*fx + b*fx, fx) == (a + b)*fx
+ assert collect(a*D(fx, x) + b*D(fx, x), fx) == (a + b)*D(fx, x)
+ assert collect(a*fxx + b*fxx, fx) == (a + b)*D(fx, x)
+ # issue 4784
+ assert collect(5*f(x) + 3*fx, fx) == 5*f(x) + 3*fx
+ assert collect(f(x) + f(x)*diff(f(x), x) + x*diff(f(x), x)*f(x), f(x).diff(x)) == \
+ (x*f(x) + f(x))*D(f(x), x) + f(x)
+ assert collect(f(x) + f(x)*diff(f(x), x) + x*diff(f(x), x)*f(x), f(x).diff(x), exact=True) == \
+ (x*f(x) + f(x))*D(f(x), x) + f(x)
+ assert collect(1/f(x) + 1/f(x)*diff(f(x), x) + x*diff(f(x), x)/f(x), f(x).diff(x), exact=True) == \
+ (1/f(x) + x/f(x))*D(f(x), x) + 1/f(x)
+ e = (1 + x*fx + fx)/f(x)
+ assert collect(e.expand(), fx) == fx*(x/f(x) + 1/f(x)) + 1/f(x)
+
+
+def test_collect_func():
+ f = ((x + a + 1)**3).expand()
+
+ assert collect(f, x) == a**3 + 3*a**2 + 3*a + x**3 + x**2*(3*a + 3) + \
+ x*(3*a**2 + 6*a + 3) + 1
+ assert collect(f, x, factor) == x**3 + 3*x**2*(a + 1) + 3*x*(a + 1)**2 + \
+ (a + 1)**3
+
+ assert collect(f, x, evaluate=False) == {
+ S.One: a**3 + 3*a**2 + 3*a + 1,
+ x: 3*a**2 + 6*a + 3, x**2: 3*a + 3,
+ x**3: 1
+ }
+
+ assert collect(f, x, factor, evaluate=False) == {
+ S.One: (a + 1)**3, x: 3*(a + 1)**2,
+ x**2: umul(S(3), a + 1), x**3: 1}
+
+
+def test_collect_order():
+ a, b, x, t = symbols('a,b,x,t')
+
+ assert collect(t + t*x + t*x**2 + O(x**3), t) == t*(1 + x + x**2 + O(x**3))
+ assert collect(t + t*x + x**2 + O(x**3), t) == \
+ t*(1 + x + O(x**3)) + x**2 + O(x**3)
+
+ f = a*x + b*x + c*x**2 + d*x**2 + O(x**3)
+ g = x*(a + b) + x**2*(c + d) + O(x**3)
+
+ assert collect(f, x) == g
+ assert collect(f, x, distribute_order_term=False) == g
+
+ f = sin(a + b).series(b, 0, 10)
+
+ assert collect(f, [sin(a), cos(a)]) == \
+ sin(a)*cos(b).series(b, 0, 10) + cos(a)*sin(b).series(b, 0, 10)
+ assert collect(f, [sin(a), cos(a)], distribute_order_term=False) == \
+ sin(a)*cos(b).series(b, 0, 10).removeO() + \
+ cos(a)*sin(b).series(b, 0, 10).removeO() + O(b**10)
+
+
+def test_rcollect():
+ assert rcollect((x**2*y + x*y + x + y)/(x + y), y) == \
+ (x + y*(1 + x + x**2))/(x + y)
+ assert rcollect(sqrt(-((x + 1)*(y + 1))), z) == sqrt(-((x + 1)*(y + 1)))
+
+
+def test_collect_D_0():
+ D = Derivative
+ f = Function('f')
+ x, a, b = symbols('x,a,b')
+ fxx = D(f(x), x, x)
+
+ assert collect(a*fxx + b*fxx, fxx) == (a + b)*fxx
+
+
+def test_collect_Wild():
+ """Collect with respect to functions with Wild argument"""
+ a, b, x, y = symbols('a b x y')
+ f = Function('f')
+ w1 = Wild('.1')
+ w2 = Wild('.2')
+ assert collect(f(x) + a*f(x), f(w1)) == (1 + a)*f(x)
+ assert collect(f(x, y) + a*f(x, y), f(w1)) == f(x, y) + a*f(x, y)
+ assert collect(f(x, y) + a*f(x, y), f(w1, w2)) == (1 + a)*f(x, y)
+ assert collect(f(x, y) + a*f(x, y), f(w1, w1)) == f(x, y) + a*f(x, y)
+ assert collect(f(x, x) + a*f(x, x), f(w1, w1)) == (1 + a)*f(x, x)
+ assert collect(a*(x + 1)**y + (x + 1)**y, w1**y) == (1 + a)*(x + 1)**y
+ assert collect(a*(x + 1)**y + (x + 1)**y, w1**b) == \
+ a*(x + 1)**y + (x + 1)**y
+ assert collect(a*(x + 1)**y + (x + 1)**y, (x + 1)**w2) == \
+ (1 + a)*(x + 1)**y
+ assert collect(a*(x + 1)**y + (x + 1)**y, w1**w2) == (1 + a)*(x + 1)**y
+
+
+def test_collect_const():
+ # coverage not provided by above tests
+ assert collect_const(2*sqrt(3) + 4*a*sqrt(5)) == \
+ 2*(2*sqrt(5)*a + sqrt(3)) # let the primitive reabsorb
+ assert collect_const(2*sqrt(3) + 4*a*sqrt(5), sqrt(3)) == \
+ 2*sqrt(3) + 4*a*sqrt(5)
+ assert collect_const(sqrt(2)*(1 + sqrt(2)) + sqrt(3) + x*sqrt(2)) == \
+ sqrt(2)*(x + 1 + sqrt(2)) + sqrt(3)
+
+ # issue 5290
+ assert collect_const(2*x + 2*y + 1, 2) == \
+ collect_const(2*x + 2*y + 1) == \
+ Add(S.One, Mul(2, x + y, evaluate=False), evaluate=False)
+ assert collect_const(-y - z) == Mul(-1, y + z, evaluate=False)
+ assert collect_const(2*x - 2*y - 2*z, 2) == \
+ Mul(2, x - y - z, evaluate=False)
+ assert collect_const(2*x - 2*y - 2*z, -2) == \
+ _unevaluated_Add(2*x, Mul(-2, y + z, evaluate=False))
+
+ # this is why the content_primitive is used
+ eq = (sqrt(15 + 5*sqrt(2))*x + sqrt(3 + sqrt(2))*y)*2
+ assert collect_sqrt(eq + 2) == \
+ 2*sqrt(sqrt(2) + 3)*(sqrt(5)*x + y) + 2
+
+ # issue 16296
+ assert collect_const(a + b + x/2 + y/2) == a + b + Mul(S.Half, x + y, evaluate=False)
+
+
+def test_issue_13143():
+ f = Function('f')
+ fx = f(x).diff(x)
+ e = f(x) + fx + f(x)*fx
+ # collect function before derivative
+ assert collect(e, Wild('w')) == f(x)*(fx + 1) + fx
+ e = f(x) + f(x)*fx + x*fx*f(x)
+ assert collect(e, fx) == (x*f(x) + f(x))*fx + f(x)
+ assert collect(e, f(x)) == (x*fx + fx + 1)*f(x)
+ e = f(x) + fx + f(x)*fx
+ assert collect(e, [f(x), fx]) == f(x)*(1 + fx) + fx
+ assert collect(e, [fx, f(x)]) == fx*(1 + f(x)) + f(x)
+
+
+def test_issue_6097():
+ assert collect(a*y**(2.0*x) + b*y**(2.0*x), y**x) == (a + b)*(y**x)**2.0
+ assert collect(a*2**(2.0*x) + b*2**(2.0*x), 2**x) == (a + b)*(2**x)**2.0
+
+
+def test_fraction_expand():
+ eq = (x + y)*y/x
+ assert eq.expand(frac=True) == fraction_expand(eq) == (x*y + y**2)/x
+ assert eq.expand() == y + y**2/x
+
+
+def test_fraction():
+ x, y, z = map(Symbol, 'xyz')
+ A = Symbol('A', commutative=False)
+
+ assert fraction(S.Half) == (1, 2)
+
+ assert fraction(x) == (x, 1)
+ assert fraction(1/x) == (1, x)
+ assert fraction(x/y) == (x, y)
+ assert fraction(x/2) == (x, 2)
+
+ assert fraction(x*y/z) == (x*y, z)
+ assert fraction(x/(y*z)) == (x, y*z)
+
+ assert fraction(1/y**2) == (1, y**2)
+ assert fraction(x/y**2) == (x, y**2)
+
+ assert fraction((x**2 + 1)/y) == (x**2 + 1, y)
+ assert fraction(x*(y + 1)/y**7) == (x*(y + 1), y**7)
+
+ assert fraction(exp(-x), exact=True) == (exp(-x), 1)
+ assert fraction((1/(x + y))/2, exact=True) == (1, Mul(2,(x + y), evaluate=False))
+
+ assert fraction(x*A/y) == (x*A, y)
+ assert fraction(x*A**-1/y) == (x*A**-1, y)
+
+ n = symbols('n', negative=True)
+ assert fraction(exp(n)) == (1, exp(-n))
+ assert fraction(exp(-n)) == (exp(-n), 1)
+
+ p = symbols('p', positive=True)
+ assert fraction(exp(-p)*log(p), exact=True) == (exp(-p)*log(p), 1)
+
+ m = Mul(1, 1, S.Half, evaluate=False)
+ assert fraction(m) == (1, 2)
+ assert fraction(m, exact=True) == (Mul(1, 1, evaluate=False), 2)
+
+ m = Mul(1, 1, S.Half, S.Half, Pow(1, -1, evaluate=False), evaluate=False)
+ assert fraction(m) == (1, 4)
+ assert fraction(m, exact=True) == \
+ (Mul(1, 1, evaluate=False), Mul(2, 2, 1, evaluate=False))
+
+
+def test_issue_5615():
+ aA, Re, a, b, D = symbols('aA Re a b D')
+ e = ((D**3*a + b*aA**3)/Re).expand()
+ assert collect(e, [aA**3/Re, a]) == e
+
+
+def test_issue_5933():
+ from sympy.geometry.polygon import (Polygon, RegularPolygon)
+ from sympy.simplify.radsimp import denom
+ x = Polygon(*RegularPolygon((0, 0), 1, 5).vertices).centroid.x
+ assert abs(denom(x).n()) > 1e-12
+ assert abs(denom(radsimp(x))) > 1e-12 # in case simplify didn't handle it
+
+
+def test_issue_14608():
+ a, b = symbols('a b', commutative=False)
+ x, y = symbols('x y')
+ raises(AttributeError, lambda: collect(a*b + b*a, a))
+ assert collect(x*y + y*(x+1), a) == x*y + y*(x+1)
+ assert collect(x*y + y*(x+1) + a*b + b*a, y) == y*(2*x + 1) + a*b + b*a
+
+
+def test_collect_abs():
+ s = abs(x) + abs(y)
+ assert collect_abs(s) == s
+ assert unchanged(Mul, abs(x), abs(y))
+ ans = Abs(x*y)
+ assert isinstance(ans, Abs)
+ assert collect_abs(abs(x)*abs(y)) == ans
+ assert collect_abs(1 + exp(abs(x)*abs(y))) == 1 + exp(ans)
+
+ # See https://github.com/sympy/sympy/issues/12910
+ p = Symbol('p', positive=True)
+ assert collect_abs(p/abs(1-p)).is_commutative is True
+
+
+def test_issue_19149():
+ eq = exp(3*x/4)
+ assert collect(eq, exp(x)) == eq
+
+def test_issue_19719():
+ a, b = symbols('a, b')
+ expr = a**2 * (b + 1) + (7 + 1/b)/a
+ collected = collect(expr, (a**2, 1/a), evaluate=False)
+ # Would return {_Dummy_20**(-2): b + 1, 1/a: 7 + 1/b} without xreplace
+ assert collected == {a**2: b + 1, 1/a: 7 + 1/b}
+
+
+def test_issue_21355():
+ assert radsimp(1/(x + sqrt(x**2))) == 1/(x + sqrt(x**2))
+ assert radsimp(1/(x - sqrt(x**2))) == 1/(x - sqrt(x**2))
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_rewrite.py b/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_rewrite.py
new file mode 100644
index 0000000000000000000000000000000000000000..56d2fb7a85bd959bd4accc2f36127429efbdbe70
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_rewrite.py
@@ -0,0 +1,31 @@
+from sympy.core.numbers import I
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.trigonometric import (cos, cot, sin)
+from sympy.testing.pytest import _both_exp_pow
+
+x, y, z, n = symbols('x,y,z,n')
+
+
+@_both_exp_pow
+def test_has():
+ assert cot(x).has(x)
+ assert cot(x).has(cot)
+ assert not cot(x).has(sin)
+ assert sin(x).has(x)
+ assert sin(x).has(sin)
+ assert not sin(x).has(cot)
+ assert exp(x).has(exp)
+
+
+@_both_exp_pow
+def test_sin_exp_rewrite():
+ assert sin(x).rewrite(sin, exp) == -I/2*(exp(I*x) - exp(-I*x))
+ assert sin(x).rewrite(sin, exp).rewrite(exp, sin) == sin(x)
+ assert cos(x).rewrite(cos, exp).rewrite(exp, cos) == cos(x)
+ assert (sin(5*y) - sin(
+ 2*x)).rewrite(sin, exp).rewrite(exp, sin) == sin(5*y) - sin(2*x)
+ assert sin(x + y).rewrite(sin, exp).rewrite(exp, sin) == sin(x + y)
+ assert cos(x + y).rewrite(cos, exp).rewrite(exp, cos) == cos(x + y)
+ # This next test currently passes... not clear whether it should or not?
+ assert cos(x).rewrite(cos, exp).rewrite(exp, sin) == cos(x)
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_sqrtdenest.py b/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_sqrtdenest.py
new file mode 100644
index 0000000000000000000000000000000000000000..41c771bb2055a1199d349ae3649f33927d79313a
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/simplify/tests/test_sqrtdenest.py
@@ -0,0 +1,204 @@
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Integer, Rational)
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import cos
+from sympy.integrals.integrals import Integral
+from sympy.simplify.sqrtdenest import sqrtdenest
+from sympy.simplify.sqrtdenest import (
+ _subsets as subsets, _sqrt_numeric_denest)
+
+r2, r3, r5, r6, r7, r10, r15, r29 = [sqrt(x) for x in (2, 3, 5, 6, 7, 10,
+ 15, 29)]
+
+
+def test_sqrtdenest():
+ d = {sqrt(5 + 2 * r6): r2 + r3,
+ sqrt(5. + 2 * r6): sqrt(5. + 2 * r6),
+ sqrt(5. + 4*sqrt(5 + 2 * r6)): sqrt(5.0 + 4*r2 + 4*r3),
+ sqrt(r2): sqrt(r2),
+ sqrt(5 + r7): sqrt(5 + r7),
+ sqrt(3 + sqrt(5 + 2*r7)):
+ 3*r2*(5 + 2*r7)**Rational(1, 4)/(2*sqrt(6 + 3*r7)) +
+ r2*sqrt(6 + 3*r7)/(2*(5 + 2*r7)**Rational(1, 4)),
+ sqrt(3 + 2*r3): 3**Rational(3, 4)*(r6/2 + 3*r2/2)/3}
+ for i in d:
+ assert sqrtdenest(i) == d[i], i
+
+
+def test_sqrtdenest2():
+ assert sqrtdenest(sqrt(16 - 2*r29 + 2*sqrt(55 - 10*r29))) == \
+ r5 + sqrt(11 - 2*r29)
+ e = sqrt(-r5 + sqrt(-2*r29 + 2*sqrt(-10*r29 + 55) + 16))
+ assert sqrtdenest(e) == root(-2*r29 + 11, 4)
+ r = sqrt(1 + r7)
+ assert sqrtdenest(sqrt(1 + r)) == sqrt(1 + r)
+ e = sqrt(((1 + sqrt(1 + 2*sqrt(3 + r2 + r5)))**2).expand())
+ assert sqrtdenest(e) == 1 + sqrt(1 + 2*sqrt(r2 + r5 + 3))
+
+ assert sqrtdenest(sqrt(5*r3 + 6*r2)) == \
+ sqrt(2)*root(3, 4) + root(3, 4)**3
+
+ assert sqrtdenest(sqrt(((1 + r5 + sqrt(1 + r3))**2).expand())) == \
+ 1 + r5 + sqrt(1 + r3)
+
+ assert sqrtdenest(sqrt(((1 + r5 + r7 + sqrt(1 + r3))**2).expand())) == \
+ 1 + sqrt(1 + r3) + r5 + r7
+
+ e = sqrt(((1 + cos(2) + cos(3) + sqrt(1 + r3))**2).expand())
+ assert sqrtdenest(e) == cos(3) + cos(2) + 1 + sqrt(1 + r3)
+
+ e = sqrt(-2*r10 + 2*r2*sqrt(-2*r10 + 11) + 14)
+ assert sqrtdenest(e) == sqrt(-2*r10 - 2*r2 + 4*r5 + 14)
+
+ # check that the result is not more complicated than the input
+ z = sqrt(-2*r29 + cos(2) + 2*sqrt(-10*r29 + 55) + 16)
+ assert sqrtdenest(z) == z
+
+ assert sqrtdenest(sqrt(r6 + sqrt(15))) == sqrt(r6 + sqrt(15))
+
+ z = sqrt(15 - 2*sqrt(31) + 2*sqrt(55 - 10*r29))
+ assert sqrtdenest(z) == z
+
+
+def test_sqrtdenest_rec():
+ assert sqrtdenest(sqrt(-4*sqrt(14) - 2*r6 + 4*sqrt(21) + 33)) == \
+ -r2 + r3 + 2*r7
+ assert sqrtdenest(sqrt(-28*r7 - 14*r5 + 4*sqrt(35) + 82)) == \
+ -7 + r5 + 2*r7
+ assert sqrtdenest(sqrt(6*r2/11 + 2*sqrt(22)/11 + 6*sqrt(11)/11 + 2)) == \
+ sqrt(11)*(r2 + 3 + sqrt(11))/11
+ assert sqrtdenest(sqrt(468*r3 + 3024*r2 + 2912*r6 + 19735)) == \
+ 9*r3 + 26 + 56*r6
+ z = sqrt(-490*r3 - 98*sqrt(115) - 98*sqrt(345) - 2107)
+ assert sqrtdenest(z) == sqrt(-1)*(7*r5 + 7*r15 + 7*sqrt(23))
+ z = sqrt(-4*sqrt(14) - 2*r6 + 4*sqrt(21) + 34)
+ assert sqrtdenest(z) == z
+ assert sqrtdenest(sqrt(-8*r2 - 2*r5 + 18)) == -r10 + 1 + r2 + r5
+ assert sqrtdenest(sqrt(8*r2 + 2*r5 - 18)) == \
+ sqrt(-1)*(-r10 + 1 + r2 + r5)
+ assert sqrtdenest(sqrt(8*r2/3 + 14*r5/3 + Rational(154, 9))) == \
+ -r10/3 + r2 + r5 + 3
+ assert sqrtdenest(sqrt(sqrt(2*r6 + 5) + sqrt(2*r7 + 8))) == \
+ sqrt(1 + r2 + r3 + r7)
+ assert sqrtdenest(sqrt(4*r15 + 8*r5 + 12*r3 + 24)) == 1 + r3 + r5 + r15
+
+ w = 1 + r2 + r3 + r5 + r7
+ assert sqrtdenest(sqrt((w**2).expand())) == w
+ z = sqrt((w**2).expand() + 1)
+ assert sqrtdenest(z) == z
+
+ z = sqrt(2*r10 + 6*r2 + 4*r5 + 12 + 10*r15 + 30*r3)
+ assert sqrtdenest(z) == z
+
+
+def test_issue_6241():
+ z = sqrt( -320 + 32*sqrt(5) + 64*r15)
+ assert sqrtdenest(z) == z
+
+
+def test_sqrtdenest3():
+ z = sqrt(13 - 2*r10 + 2*r2*sqrt(-2*r10 + 11))
+ assert sqrtdenest(z) == -1 + r2 + r10
+ assert sqrtdenest(z, max_iter=1) == -1 + sqrt(2) + sqrt(10)
+ z = sqrt(sqrt(r2 + 2) + 2)
+ assert sqrtdenest(z) == z
+ assert sqrtdenest(sqrt(-2*r10 + 4*r2*sqrt(-2*r10 + 11) + 20)) == \
+ sqrt(-2*r10 - 4*r2 + 8*r5 + 20)
+ assert sqrtdenest(sqrt((112 + 70*r2) + (46 + 34*r2)*r5)) == \
+ r10 + 5 + 4*r2 + 3*r5
+ z = sqrt(5 + sqrt(2*r6 + 5)*sqrt(-2*r29 + 2*sqrt(-10*r29 + 55) + 16))
+ r = sqrt(-2*r29 + 11)
+ assert sqrtdenest(z) == sqrt(r2*r + r3*r + r10 + r15 + 5)
+
+ n = sqrt(2*r6/7 + 2*r7/7 + 2*sqrt(42)/7 + 2)
+ d = sqrt(16 - 2*r29 + 2*sqrt(55 - 10*r29))
+ assert sqrtdenest(n/d) == r7*(1 + r6 + r7)/(Mul(7, (sqrt(-2*r29 + 11) + r5),
+ evaluate=False))
+
+
+def test_sqrtdenest4():
+ # see Denest_en.pdf in https://github.com/sympy/sympy/issues/3192
+ z = sqrt(8 - r2*sqrt(5 - r5) - sqrt(3)*(1 + r5))
+ z1 = sqrtdenest(z)
+ c = sqrt(-r5 + 5)
+ z1 = ((-r15*c - r3*c + c + r5*c - r6 - r2 + r10 + sqrt(30))/4).expand()
+ assert sqrtdenest(z) == z1
+
+ z = sqrt(2*r2*sqrt(r2 + 2) + 5*r2 + 4*sqrt(r2 + 2) + 8)
+ assert sqrtdenest(z) == r2 + sqrt(r2 + 2) + 2
+
+ w = 2 + r2 + r3 + (1 + r3)*sqrt(2 + r2 + 5*r3)
+ z = sqrt((w**2).expand())
+ assert sqrtdenest(z) == w.expand()
+
+
+def test_sqrt_symbolic_denest():
+ x = Symbol('x')
+ z = sqrt(((1 + sqrt(sqrt(2 + x) + 3))**2).expand())
+ assert sqrtdenest(z) == sqrt((1 + sqrt(sqrt(2 + x) + 3))**2)
+ z = sqrt(((1 + sqrt(sqrt(2 + cos(1)) + 3))**2).expand())
+ assert sqrtdenest(z) == 1 + sqrt(sqrt(2 + cos(1)) + 3)
+ z = ((1 + cos(2))**4 + 1).expand()
+ assert sqrtdenest(z) == z
+ z = sqrt(((1 + sqrt(sqrt(2 + cos(3*x)) + 3))**2 + 1).expand())
+ assert sqrtdenest(z) == z
+ c = cos(3)
+ c2 = c**2
+ assert sqrtdenest(sqrt(2*sqrt(1 + r3)*c + c2 + 1 + r3*c2)) == \
+ -1 - sqrt(1 + r3)*c
+ ra = sqrt(1 + r3)
+ z = sqrt(20*ra*sqrt(3 + 3*r3) + 12*r3*ra*sqrt(3 + 3*r3) + 64*r3 + 112)
+ assert sqrtdenest(z) == z
+
+
+def test_issue_5857():
+ from sympy.abc import x, y
+ z = sqrt(1/(4*r3 + 7) + 1)
+ ans = (r2 + r6)/(r3 + 2)
+ assert sqrtdenest(z) == ans
+ assert sqrtdenest(1 + z) == 1 + ans
+ assert sqrtdenest(Integral(z + 1, (x, 1, 2))) == \
+ Integral(1 + ans, (x, 1, 2))
+ assert sqrtdenest(x + sqrt(y)) == x + sqrt(y)
+ ans = (r2 + r6)/(r3 + 2)
+ assert sqrtdenest(z) == ans
+ assert sqrtdenest(1 + z) == 1 + ans
+ assert sqrtdenest(Integral(z + 1, (x, 1, 2))) == \
+ Integral(1 + ans, (x, 1, 2))
+ assert sqrtdenest(x + sqrt(y)) == x + sqrt(y)
+
+
+def test_subsets():
+ assert subsets(1) == [[1]]
+ assert subsets(4) == [
+ [1, 0, 0, 0], [0, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 0], [1, 0, 1, 0],
+ [0, 1, 1, 0], [1, 1, 1, 0], [0, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 1],
+ [1, 1, 0, 1], [0, 0, 1, 1], [1, 0, 1, 1], [0, 1, 1, 1], [1, 1, 1, 1]]
+
+
+def test_issue_5653():
+ assert sqrtdenest(
+ sqrt(2 + sqrt(2 + sqrt(2)))) == sqrt(2 + sqrt(2 + sqrt(2)))
+
+def test_issue_12420():
+ assert sqrtdenest((3 - sqrt(2)*sqrt(4 + 3*I) + 3*I)/2) == I
+ e = 3 - sqrt(2)*sqrt(4 + I) + 3*I
+ assert sqrtdenest(e) == e
+
+def test_sqrt_ratcomb():
+ assert sqrtdenest(sqrt(1 + r3) + sqrt(3 + 3*r3) - sqrt(10 + 6*r3)) == 0
+
+def test_issue_18041():
+ e = -sqrt(-2 + 2*sqrt(3)*I)
+ assert sqrtdenest(e) == -1 - sqrt(3)*I
+
+def test_issue_19914():
+ a = Integer(-8)
+ b = Integer(-1)
+ r = Integer(63)
+ d2 = a*a - b*b*r
+
+ assert _sqrt_numeric_denest(a, b, r, d2) == \
+ sqrt(14)*I/2 + 3*sqrt(2)*I/2
+ assert sqrtdenest(sqrt(-8-sqrt(63))) == sqrt(14)*I/2 + 3*sqrt(2)*I/2
diff --git a/janus/lib/python3.10/site-packages/sympy/simplify/trigsimp.py b/janus/lib/python3.10/site-packages/sympy/simplify/trigsimp.py
new file mode 100644
index 0000000000000000000000000000000000000000..733e6b0a0b8a91055e61868f556ac2a5c0610ce6
--- /dev/null
+++ b/janus/lib/python3.10/site-packages/sympy/simplify/trigsimp.py
@@ -0,0 +1,1253 @@
+from collections import defaultdict
+from functools import reduce
+
+from sympy.core import (sympify, Basic, S, Expr, factor_terms,
+ Mul, Add, bottom_up)
+from sympy.core.cache import cacheit
+from sympy.core.function import (count_ops, _mexpand, FunctionClass, expand,
+ expand_mul, _coeff_isneg, Derivative)
+from sympy.core.numbers import I, Integer
+from sympy.core.intfunc import igcd
+from sympy.core.sorting import _nodes
+from sympy.core.symbol import Dummy, symbols, Wild
+from sympy.external.gmpy import SYMPY_INTS
+from sympy.functions import sin, cos, exp, cosh, tanh, sinh, tan, cot, coth
+from sympy.functions import atan2
+from sympy.functions.elementary.hyperbolic import HyperbolicFunction
+from sympy.functions.elementary.trigonometric import TrigonometricFunction
+from sympy.polys import Poly, factor, cancel, parallel_poly_from_expr
+from sympy.polys.domains import ZZ
+from sympy.polys.polyerrors import PolificationFailed
+from sympy.polys.polytools import groebner
+from sympy.simplify.cse_main import cse
+from sympy.strategies.core import identity
+from sympy.strategies.tree import greedy
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import debug
+
+def trigsimp_groebner(expr, hints=[], quick=False, order="grlex",
+ polynomial=False):
+ """
+ Simplify trigonometric expressions using a groebner basis algorithm.
+
+ Explanation
+ ===========
+
+ This routine takes a fraction involving trigonometric or hyperbolic
+ expressions, and tries to simplify it. The primary metric is the
+ total degree. Some attempts are made to choose the simplest possible
+ expression of the minimal degree, but this is non-rigorous, and also
+ very slow (see the ``quick=True`` option).
+
+ If ``polynomial`` is set to True, instead of simplifying numerator and
+ denominator together, this function just brings numerator and denominator
+ into a canonical form. This is much faster, but has potentially worse
+ results. However, if the input is a polynomial, then the result is
+ guaranteed to be an equivalent polynomial of minimal degree.
+
+ The most important option is hints. Its entries can be any of the
+ following:
+
+ - a natural number
+ - a function
+ - an iterable of the form (func, var1, var2, ...)
+ - anything else, interpreted as a generator
+
+ A number is used to indicate that the search space should be increased.
+ A function is used to indicate that said function is likely to occur in a
+ simplified expression.
+ An iterable is used indicate that func(var1 + var2 + ...) is likely to
+ occur in a simplified .
+ An additional generator also indicates that it is likely to occur.
+ (See examples below).
+
+ This routine carries out various computationally intensive algorithms.
+ The option ``quick=True`` can be used to suppress one particularly slow
+ step (at the expense of potentially more complicated results, but never at
+ the expense of increased total degree).
+
+ Examples
+ ========
+
+ >>> from sympy.abc import x, y
+ >>> from sympy import sin, tan, cos, sinh, cosh, tanh
+ >>> from sympy.simplify.trigsimp import trigsimp_groebner
+
+ Suppose you want to simplify ``sin(x)*cos(x)``. Naively, nothing happens:
+
+ >>> ex = sin(x)*cos(x)
+ >>> trigsimp_groebner(ex)
+ sin(x)*cos(x)
+
+ This is because ``trigsimp_groebner`` only looks for a simplification
+ involving just ``sin(x)`` and ``cos(x)``. You can tell it to also try
+ ``2*x`` by passing ``hints=[2]``:
+
+ >>> trigsimp_groebner(ex, hints=[2])
+ sin(2*x)/2
+ >>> trigsimp_groebner(sin(x)**2 - cos(x)**2, hints=[2])
+ -cos(2*x)
+
+ Increasing the search space this way can quickly become expensive. A much
+ faster way is to give a specific expression that is likely to occur:
+
+ >>> trigsimp_groebner(ex, hints=[sin(2*x)])
+ sin(2*x)/2
+
+ Hyperbolic expressions are similarly supported:
+
+ >>> trigsimp_groebner(sinh(2*x)/sinh(x))
+ 2*cosh(x)
+
+ Note how no hints had to be passed, since the expression already involved
+ ``2*x``.
+
+ The tangent function is also supported. You can either pass ``tan`` in the
+ hints, to indicate that tan should be tried whenever cosine or sine are,
+ or you can pass a specific generator:
+
+ >>> trigsimp_groebner(sin(x)/cos(x), hints=[tan])
+ tan(x)
+ >>> trigsimp_groebner(sinh(x)/cosh(x), hints=[tanh(x)])
+ tanh(x)
+
+ Finally, you can use the iterable form to suggest that angle sum formulae
+ should be tried:
+
+ >>> ex = (tan(x) + tan(y))/(1 - tan(x)*tan(y))
+ >>> trigsimp_groebner(ex, hints=[(tan, x, y)])
+ tan(x + y)
+ """
+ # TODO
+ # - preprocess by replacing everything by funcs we can handle
+ # - optionally use cot instead of tan
+ # - more intelligent hinting.
+ # For example, if the ideal is small, and we have sin(x), sin(y),
+ # add sin(x + y) automatically... ?
+ # - algebraic numbers ...
+ # - expressions of lowest degree are not distinguished properly
+ # e.g. 1 - sin(x)**2
+ # - we could try to order the generators intelligently, so as to influence
+ # which monomials appear in the quotient basis
+
+ # THEORY
+ # ------
+ # Ratsimpmodprime above can be used to "simplify" a rational function
+ # modulo a prime ideal. "Simplify" mainly means finding an equivalent
+ # expression of lower total degree.
+ #
+ # We intend to use this to simplify trigonometric functions. To do that,
+ # we need to decide (a) which ring to use, and (b) modulo which ideal to
+ # simplify. In practice, (a) means settling on a list of "generators"
+ # a, b, c, ..., such that the fraction we want to simplify is a rational
+ # function in a, b, c, ..., with coefficients in ZZ (integers).
+ # (2) means that we have to decide what relations to impose on the
+ # generators. There are two practical problems:
+ # (1) The ideal has to be *prime* (a technical term).
+ # (2) The relations have to be polynomials in the generators.
+ #
+ # We typically have two kinds of generators:
+ # - trigonometric expressions, like sin(x), cos(5*x), etc
+ # - "everything else", like gamma(x), pi, etc.
+ #
+ # Since this function is trigsimp, we will concentrate on what to do with
+ # trigonometric expressions. We can also simplify hyperbolic expressions,
+ # but the extensions should be clear.
+ #
+ # One crucial point is that all *other* generators really should behave
+ # like indeterminates. In particular if (say) "I" is one of them, then
+ # in fact I**2 + 1 = 0 and we may and will compute non-sensical
+ # expressions. However, we can work with a dummy and add the relation
+ # I**2 + 1 = 0 to our ideal, then substitute back in the end.
+ #
+ # Now regarding trigonometric generators. We split them into groups,
+ # according to the argument of the trigonometric functions. We want to
+ # organise this in such a way that most trigonometric identities apply in
+ # the same group. For example, given sin(x), cos(2*x) and cos(y), we would
+ # group as [sin(x), cos(2*x)] and [cos(y)].
+ #
+ # Our prime ideal will be built in three steps:
+ # (1) For each group, compute a "geometrically prime" ideal of relations.
+ # Geometrically prime means that it generates a prime ideal in
+ # CC[gens], not just ZZ[gens].
+ # (2) Take the union of all the generators of the ideals for all groups.
+ # By the geometric primality condition, this is still prime.
+ # (3) Add further inter-group relations which preserve primality.
+ #
+ # Step (1) works as follows. We will isolate common factors in the
+ # argument, so that all our generators are of the form sin(n*x), cos(n*x)
+ # or tan(n*x), with n an integer. Suppose first there are no tan terms.
+ # The ideal [sin(x)**2 + cos(x)**2 - 1] is geometrically prime, since
+ # X**2 + Y**2 - 1 is irreducible over CC.
+ # Now, if we have a generator sin(n*x), than we can, using trig identities,
+ # express sin(n*x) as a polynomial in sin(x) and cos(x). We can add this
+ # relation to the ideal, preserving geometric primality, since the quotient
+ # ring is unchanged.
+ # Thus we have treated all sin and cos terms.
+ # For tan(n*x), we add a relation tan(n*x)*cos(n*x) - sin(n*x) = 0.
+ # (This requires of course that we already have relations for cos(n*x) and
+ # sin(n*x).) It is not obvious, but it seems that this preserves geometric
+ # primality.
+ # XXX A real proof would be nice. HELP!
+ # Sketch that is a prime ideal of
+ # CC[S, C, T]:
+ # - it suffices to show that the projective closure in CP**3 is
+ # irreducible
+ # - using the half-angle substitutions, we can express sin(x), tan(x),
+ # cos(x) as rational functions in tan(x/2)
+ # - from this, we get a rational map from CP**1 to our curve
+ # - this is a morphism, hence the curve is prime
+ #
+ # Step (2) is trivial.
+ #
+ # Step (3) works by adding selected relations of the form
+ # sin(x + y) - sin(x)*cos(y) - sin(y)*cos(x), etc. Geometric primality is
+ # preserved by the same argument as before.
+
+ def parse_hints(hints):
+ """Split hints into (n, funcs, iterables, gens)."""
+ n = 1
+ funcs, iterables, gens = [], [], []
+ for e in hints:
+ if isinstance(e, (SYMPY_INTS, Integer)):
+ n = e
+ elif isinstance(e, FunctionClass):
+ funcs.append(e)
+ elif iterable(e):
+ iterables.append((e[0], e[1:]))
+ # XXX sin(x+2y)?
+ # Note: we go through polys so e.g.
+ # sin(-x) -> -sin(x) -> sin(x)
+ gens.extend(parallel_poly_from_expr(
+ [e[0](x) for x in e[1:]] + [e[0](Add(*e[1:]))])[1].gens)
+ else:
+ gens.append(e)
+ return n, funcs, iterables, gens
+
+ def build_ideal(x, terms):
+ """
+ Build generators for our ideal. ``Terms`` is an iterable with elements of
+ the form (fn, coeff), indicating that we have a generator fn(coeff*x).
+
+ If any of the terms is trigonometric, sin(x) and cos(x) are guaranteed
+ to appear in terms. Similarly for hyperbolic functions. For tan(n*x),
+ sin(n*x) and cos(n*x) are guaranteed.
+ """
+ I = []
+ y = Dummy('y')
+ for fn, coeff in terms:
+ for c, s, t, rel in (
+ [cos, sin, tan, cos(x)**2 + sin(x)**2 - 1],
+ [cosh, sinh, tanh, cosh(x)**2 - sinh(x)**2 - 1]):
+ if coeff == 1 and fn in [c, s]:
+ I.append(rel)
+ elif fn == t:
+ I.append(t(coeff*x)*c(coeff*x) - s(coeff*x))
+ elif fn in [c, s]:
+ cn = fn(coeff*y).expand(trig=True).subs(y, x)
+ I.append(fn(coeff*x) - cn)
+ return list(set(I))
+
+ def analyse_gens(gens, hints):
+ """
+ Analyse the generators ``gens``, using the hints ``hints``.
+
+ The meaning of ``hints`` is described in the main docstring.
+ Return a new list of generators, and also the ideal we should
+ work with.
+ """
+ # First parse the hints
+ n, funcs, iterables, extragens = parse_hints(hints)
+ debug('n=%s funcs: %s iterables: %s extragens: %s',
+ (funcs, iterables, extragens))
+
+ # We just add the extragens to gens and analyse them as before
+ gens = list(gens)
+ gens.extend(extragens)
+
+ # remove duplicates
+ funcs = list(set(funcs))
+ iterables = list(set(iterables))
+ gens = list(set(gens))
+
+ # all the functions we can do anything with
+ allfuncs = {sin, cos, tan, sinh, cosh, tanh}
+ # sin(3*x) -> ((3, x), sin)
+ trigterms = [(g.args[0].as_coeff_mul(), g.func) for g in gens
+ if g.func in allfuncs]
+ # Our list of new generators - start with anything that we cannot
+ # work with (i.e. is not a trigonometric term)
+ freegens = [g for g in gens if g.func not in allfuncs]
+ newgens = []
+ trigdict = {}
+ for (coeff, var), fn in trigterms:
+ trigdict.setdefault(var, []).append((coeff, fn))
+ res = [] # the ideal
+
+ for key, val in trigdict.items():
+ # We have now assembeled a dictionary. Its keys are common
+ # arguments in trigonometric expressions, and values are lists of
+ # pairs (fn, coeff). x0, (fn, coeff) in trigdict means that we
+ # need to deal with fn(coeff*x0). We take the rational gcd of the
+ # coeffs, call it ``gcd``. We then use x = x0/gcd as "base symbol",
+ # all other arguments are integral multiples thereof.
+ # We will build an ideal which works with sin(x), cos(x).
+ # If hint tan is provided, also work with tan(x). Moreover, if
+ # n > 1, also work with sin(k*x) for k <= n, and similarly for cos
+ # (and tan if the hint is provided). Finally, any generators which
+ # the ideal does not work with but we need to accommodate (either
+ # because it was in expr or because it was provided as a hint)
+ # we also build into the ideal.
+ # This selection process is expressed in the list ``terms``.
+ # build_ideal then generates the actual relations in our ideal,
+ # from this list.
+ fns = [x[1] for x in val]
+ val = [x[0] for x in val]
+ gcd = reduce(igcd, val)
+ terms = [(fn, v/gcd) for (fn, v) in zip(fns, val)]
+ fs = set(funcs + fns)
+ for c, s, t in ([cos, sin, tan], [cosh, sinh, tanh]):
+ if any(x in fs for x in (c, s, t)):
+ fs.add(c)
+ fs.add(s)
+ for fn in fs:
+ for k in range(1, n + 1):
+ terms.append((fn, k))
+ extra = []
+ for fn, v in terms:
+ if fn == tan:
+ extra.append((sin, v))
+ extra.append((cos, v))
+ if fn in [sin, cos] and tan in fs:
+ extra.append((tan, v))
+ if fn == tanh:
+ extra.append((sinh, v))
+ extra.append((cosh, v))
+ if fn in [sinh, cosh] and tanh in fs:
+ extra.append((tanh, v))
+ terms.extend(extra)
+ x = gcd*Mul(*key)
+ r = build_ideal(x, terms)
+ res.extend(r)
+ newgens.extend({fn(v*x) for fn, v in terms})
+
+ # Add generators for compound expressions from iterables
+ for fn, args in iterables:
+ if fn == tan:
+ # Tan expressions are recovered from sin and cos.
+ iterables.extend([(sin, args), (cos, args)])
+ elif fn == tanh:
+ # Tanh expressions are recovered from sihn and cosh.
+ iterables.extend([(sinh, args), (cosh, args)])
+ else:
+ dummys = symbols('d:%i' % len(args), cls=Dummy)
+ expr = fn( Add(*dummys)).expand(trig=True).subs(list(zip(dummys, args)))
+ res.append(fn(Add(*args)) - expr)
+
+ if myI in gens:
+ res.append(myI**2 + 1)
+ freegens.remove(myI)
+ newgens.append(myI)
+
+ return res, freegens, newgens
+
+ myI = Dummy('I')
+ expr = expr.subs(S.ImaginaryUnit, myI)
+ subs = [(myI, S.ImaginaryUnit)]
+
+ num, denom = cancel(expr).as_numer_denom()
+ try:
+ (pnum, pdenom), opt = parallel_poly_from_expr([num, denom])
+ except PolificationFailed:
+ return expr
+ debug('initial gens:', opt.gens)
+ ideal, freegens, gens = analyse_gens(opt.gens, hints)
+ debug('ideal:', ideal)
+ debug('new gens:', gens, " -- len", len(gens))
+ debug('free gens:', freegens, " -- len", len(gens))
+ # NOTE we force the domain to be ZZ to stop polys from injecting generators
+ # (which is usually a sign of a bug in the way we build the ideal)
+ if not gens:
+ return expr
+ G = groebner(ideal, order=order, gens=gens, domain=ZZ)
+ debug('groebner basis:', list(G), " -- len", len(G))
+
+ # If our fraction is a polynomial in the free generators, simplify all
+ # coefficients separately:
+
+ from sympy.simplify.ratsimp import ratsimpmodprime
+
+ if freegens and pdenom.has_only_gens(*set(gens).intersection(pdenom.gens)):
+ num = Poly(num, gens=gens+freegens).eject(*gens)
+ res = []
+ for monom, coeff in num.terms():
+ ourgens = set(parallel_poly_from_expr([coeff, denom])[1].gens)
+ # We compute the transitive closure of all generators that can
+ # be reached from our generators through relations in the ideal.
+ changed = True
+ while changed:
+ changed = False
+ for p in ideal:
+ p = Poly(p)
+ if not ourgens.issuperset(p.gens) and \
+ not p.has_only_gens(*set(p.gens).difference(ourgens)):
+ changed = True
+ ourgens.update(p.exclude().gens)
+ # NOTE preserve order!
+ realgens = [x for x in gens if x in ourgens]
+ # The generators of the ideal have now been (implicitly) split
+ # into two groups: those involving ourgens and those that don't.
+ # Since we took the transitive closure above, these two groups
+ # live in subgrings generated by a *disjoint* set of variables.
+ # Any sensible groebner basis algorithm will preserve this disjoint
+ # structure (i.e. the elements of the groebner basis can be split
+ # similarly), and and the two subsets of the groebner basis then
+ # form groebner bases by themselves. (For the smaller generating
+ # sets, of course.)
+ ourG = [g.as_expr() for g in G.polys if
+ g.has_only_gens(*ourgens.intersection(g.gens))]
+ res.append(Mul(*[a**b for a, b in zip(freegens, monom)]) * \
+ ratsimpmodprime(coeff/denom, ourG, order=order,
+ gens=realgens, quick=quick, domain=ZZ,
+ polynomial=polynomial).subs(subs))
+ return Add(*res)
+ # NOTE The following is simpler and has less assumptions on the
+ # groebner basis algorithm. If the above turns out to be broken,
+ # use this.
+ return Add(*[Mul(*[a**b for a, b in zip(freegens, monom)]) * \
+ ratsimpmodprime(coeff/denom, list(G), order=order,
+ gens=gens, quick=quick, domain=ZZ)
+ for monom, coeff in num.terms()])
+ else:
+ return ratsimpmodprime(
+ expr, list(G), order=order, gens=freegens+gens,
+ quick=quick, domain=ZZ, polynomial=polynomial).subs(subs)
+
+
+_trigs = (TrigonometricFunction, HyperbolicFunction)
+
+
+def _trigsimp_inverse(rv):
+
+ def check_args(x, y):
+ try:
+ return x.args[0] == y.args[0]
+ except IndexError:
+ return False
+
+ def f(rv):
+ # for simple functions
+ g = getattr(rv, 'inverse', None)
+ if (g is not None and isinstance(rv.args[0], g()) and
+ isinstance(g()(1), TrigonometricFunction)):
+ return rv.args[0].args[0]
+
+ # for atan2 simplifications, harder because atan2 has 2 args
+ if isinstance(rv, atan2):
+ y, x = rv.args
+ if _coeff_isneg(y):
+ return -f(atan2(-y, x))
+ elif _coeff_isneg(x):
+ return S.Pi - f(atan2(y, -x))
+
+ if check_args(x, y):
+ if isinstance(y, sin) and isinstance(x, cos):
+ return x.args[0]
+ if isinstance(y, cos) and isinstance(x, sin):
+ return S.Pi / 2 - x.args[0]
+
+ return rv
+
+ return bottom_up(rv, f)
+
+
+def trigsimp(expr, inverse=False, **opts):
+ """Returns a reduced expression by using known trig identities.
+
+ Parameters
+ ==========
+
+ inverse : bool, optional
+ If ``inverse=True``, it will be assumed that a composition of inverse
+ functions, such as sin and asin, can be cancelled in any order.
+ For example, ``asin(sin(x))`` will yield ``x`` without checking whether
+ x belongs to the set where this relation is true. The default is False.
+ Default : True
+
+ method : string, optional
+ Specifies the method to use. Valid choices are:
+
+ - ``'matching'``, default
+ - ``'groebner'``
+ - ``'combined'``
+ - ``'fu'``
+ - ``'old'``
+
+ If ``'matching'``, simplify the expression recursively by targeting
+ common patterns. If ``'groebner'``, apply an experimental groebner
+ basis algorithm. In this case further options are forwarded to
+ ``trigsimp_groebner``, please refer to
+ its docstring. If ``'combined'``, it first runs the groebner basis
+ algorithm with small default parameters, then runs the ``'matching'``
+ algorithm. If ``'fu'``, run the collection of trigonometric
+ transformations described by Fu, et al. (see the
+ :py:func:`~sympy.simplify.fu.fu` docstring). If ``'old'``, the original
+ SymPy trig simplification function is run.
+ opts :
+ Optional keyword arguments passed to the method. See each method's
+ function docstring for details.
+
+ Examples
+ ========
+
+ >>> from sympy import trigsimp, sin, cos, log
+ >>> from sympy.abc import x
+ >>> e = 2*sin(x)**2 + 2*cos(x)**2
+ >>> trigsimp(e)
+ 2
+
+ Simplification occurs wherever trigonometric functions are located.
+
+ >>> trigsimp(log(e))
+ log(2)
+
+ Using ``method='groebner'`` (or ``method='combined'``) might lead to
+ greater simplification.
+
+ The old trigsimp routine can be accessed as with method ``method='old'``.
+
+ >>> from sympy import coth, tanh
+ >>> t = 3*tanh(x)**7 - 2/coth(x)**7
+ >>> trigsimp(t, method='old') == t
+ True
+ >>> trigsimp(t)
+ tanh(x)**7
+
+ """
+ from sympy.simplify.fu import fu
+
+ expr = sympify(expr)
+
+ _eval_trigsimp = getattr(expr, '_eval_trigsimp', None)
+ if _eval_trigsimp is not None:
+ return _eval_trigsimp(**opts)
+
+ old = opts.pop('old', False)
+ if not old:
+ opts.pop('deep', None)
+ opts.pop('recursive', None)
+ method = opts.pop('method', 'matching')
+ else:
+ method = 'old'
+
+ def groebnersimp(ex, **opts):
+ def traverse(e):
+ if e.is_Atom:
+ return e
+ args = [traverse(x) for x in e.args]
+ if e.is_Function or e.is_Pow:
+ args = [trigsimp_groebner(x, **opts) for x in args]
+ return e.func(*args)
+ new = traverse(ex)
+ if not isinstance(new, Expr):
+ return new
+ return trigsimp_groebner(new, **opts)
+
+ trigsimpfunc = {
+ 'fu': (lambda x: fu(x, **opts)),
+ 'matching': (lambda x: futrig(x)),
+ 'groebner': (lambda x: groebnersimp(x, **opts)),
+ 'combined': (lambda x: futrig(groebnersimp(x,
+ polynomial=True, hints=[2, tan]))),
+ 'old': lambda x: trigsimp_old(x, **opts),
+ }[method]
+
+ expr_simplified = trigsimpfunc(expr)
+ if inverse:
+ expr_simplified = _trigsimp_inverse(expr_simplified)
+
+ return expr_simplified
+
+
+def exptrigsimp(expr):
+ """
+ Simplifies exponential / trigonometric / hyperbolic functions.
+
+ Examples
+ ========
+
+ >>> from sympy import exptrigsimp, exp, cosh, sinh
+ >>> from sympy.abc import z
+
+ >>> exptrigsimp(exp(z) + exp(-z))
+ 2*cosh(z)
+ >>> exptrigsimp(cosh(z) - sinh(z))
+ exp(-z)
+ """
+ from sympy.simplify.fu import hyper_as_trig, TR2i
+
+ def exp_trig(e):
+ # select the better of e, and e rewritten in terms of exp or trig
+ # functions
+ choices = [e]
+ if e.has(*_trigs):
+ choices.append(e.rewrite(exp))
+ choices.append(e.rewrite(cos))
+ return min(*choices, key=count_ops)
+ newexpr = bottom_up(expr, exp_trig)
+
+ def f(rv):
+ if not rv.is_Mul:
+ return rv
+ commutative_part, noncommutative_part = rv.args_cnc()
+ # Since as_powers_dict loses order information,
+ # if there is more than one noncommutative factor,
+ # it should only be used to simplify the commutative part.
+ if (len(noncommutative_part) > 1):
+ return f(Mul(*commutative_part))*Mul(*noncommutative_part)
+ rvd = rv.as_powers_dict()
+ newd = rvd.copy()
+
+ def signlog(expr, sign=S.One):
+ if expr is S.Exp1:
+ return sign, S.One
+ elif isinstance(expr, exp) or (expr.is_Pow and expr.base == S.Exp1):
+ return sign, expr.exp
+ elif sign is S.One:
+ return signlog(-expr, sign=-S.One)
+ else:
+ return None, None
+
+ ee = rvd[S.Exp1]
+ for k in rvd:
+ if k.is_Add and len(k.args) == 2:
+ # k == c*(1 + sign*E**x)
+ c = k.args[0]
+ sign, x = signlog(k.args[1]/c)
+ if not x:
+ continue
+ m = rvd[k]
+ newd[k] -= m
+ if ee == -x*m/2:
+ # sinh and cosh
+ newd[S.Exp1] -= ee
+ ee = 0
+ if sign == 1:
+ newd[2*c*cosh(x/2)] += m
+ else:
+ newd[-2*c*sinh(x/2)] += m
+ elif newd[1 - sign*S.Exp1**x] == -m:
+ # tanh
+ del newd[1 - sign*S.Exp1**x]
+ if sign == 1:
+ newd[-c/tanh(x/2)] += m
+ else:
+ newd[-c*tanh(x/2)] += m
+ else:
+ newd[1 + sign*S.Exp1**x] += m
+ newd[c] += m
+
+ return Mul(*[k**newd[k] for k in newd])
+ newexpr = bottom_up(newexpr, f)
+
+ # sin/cos and sinh/cosh ratios to tan and tanh, respectively
+ if newexpr.has(HyperbolicFunction):
+ e, f = hyper_as_trig(newexpr)
+ newexpr = f(TR2i(e))
+ if newexpr.has(TrigonometricFunction):
+ newexpr = TR2i(newexpr)
+
+ # can we ever generate an I where there was none previously?
+ if not (newexpr.has(I) and not expr.has(I)):
+ expr = newexpr
+ return expr
+
+#-------------------- the old trigsimp routines ---------------------
+
+def trigsimp_old(expr, *, first=True, **opts):
+ """
+ Reduces expression by using known trig identities.
+
+ Notes
+ =====
+
+ deep:
+ - Apply trigsimp inside all objects with arguments
+
+ recursive:
+ - Use common subexpression elimination (cse()) and apply
+ trigsimp recursively (this is quite expensive if the
+ expression is large)
+
+ method:
+ - Determine the method to use. Valid choices are 'matching' (default),
+ 'groebner', 'combined', 'fu' and 'futrig'. If 'matching', simplify the
+ expression recursively by pattern matching. If 'groebner', apply an
+ experimental groebner basis algorithm. In this case further options
+ are forwarded to ``trigsimp_groebner``, please refer to its docstring.
+ If 'combined', first run the groebner basis algorithm with small
+ default parameters, then run the 'matching' algorithm. 'fu' runs the
+ collection of trigonometric transformations described by Fu, et al.
+ (see the `fu` docstring) while `futrig` runs a subset of Fu-transforms
+ that mimic the behavior of `trigsimp`.
+
+ compare:
+ - show input and output from `trigsimp` and `futrig` when different,
+ but returns the `trigsimp` value.
+
+ Examples
+ ========
+
+ >>> from sympy import trigsimp, sin, cos, log, cot
+ >>> from sympy.abc import x
+ >>> e = 2*sin(x)**2 + 2*cos(x)**2
+ >>> trigsimp(e, old=True)
+ 2
+ >>> trigsimp(log(e), old=True)
+ log(2*sin(x)**2 + 2*cos(x)**2)
+ >>> trigsimp(log(e), deep=True, old=True)
+ log(2)
+
+ Using `method="groebner"` (or `"combined"`) can sometimes lead to a lot
+ more simplification:
+
+ >>> e = (-sin(x) + 1)/cos(x) + cos(x)/(-sin(x) + 1)
+ >>> trigsimp(e, old=True)
+ (1 - sin(x))/cos(x) + cos(x)/(1 - sin(x))
+ >>> trigsimp(e, method="groebner", old=True)
+ 2/cos(x)
+
+ >>> trigsimp(1/cot(x)**2, compare=True, old=True)
+ futrig: tan(x)**2
+ cot(x)**(-2)
+
+ """
+ old = expr
+ if first:
+ if not expr.has(*_trigs):
+ return expr
+
+ trigsyms = set().union(*[t.free_symbols for t in expr.atoms(*_trigs)])
+ if len(trigsyms) > 1:
+ from sympy.simplify.simplify import separatevars
+
+ d = separatevars(expr)
+ if d.is_Mul:
+ d = separatevars(d, dict=True) or d
+ if isinstance(d, dict):
+ expr = 1
+ for v in d.values():
+ # remove hollow factoring
+ was = v
+ v = expand_mul(v)
+ opts['first'] = False
+ vnew = trigsimp(v, **opts)
+ if vnew == v:
+ vnew = was
+ expr *= vnew
+ old = expr
+ else:
+ if d.is_Add:
+ for s in trigsyms:
+ r, e = expr.as_independent(s)
+ if r:
+ opts['first'] = False
+ expr = r + trigsimp(e, **opts)
+ if not expr.is_Add:
+ break
+ old = expr
+
+ recursive = opts.pop('recursive', False)
+ deep = opts.pop('deep', False)
+ method = opts.pop('method', 'matching')
+
+ def groebnersimp(ex, deep, **opts):
+ def traverse(e):
+ if e.is_Atom:
+ return e
+ args = [traverse(x) for x in e.args]
+ if e.is_Function or e.is_Pow:
+ args = [trigsimp_groebner(x, **opts) for x in args]
+ return e.func(*args)
+ if deep:
+ ex = traverse(ex)
+ return trigsimp_groebner(ex, **opts)
+
+ trigsimpfunc = {
+ 'matching': (lambda x, d: _trigsimp(x, d)),
+ 'groebner': (lambda x, d: groebnersimp(x, d, **opts)),
+ 'combined': (lambda x, d: _trigsimp(groebnersimp(x,
+ d, polynomial=True, hints=[2, tan]),
+ d))
+ }[method]
+
+ if recursive:
+ w, g = cse(expr)
+ g = trigsimpfunc(g[0], deep)
+
+ for sub in reversed(w):
+ g = g.subs(sub[0], sub[1])
+ g = trigsimpfunc(g, deep)
+ result = g
+ else:
+ result = trigsimpfunc(expr, deep)
+
+ if opts.get('compare', False):
+ f = futrig(old)
+ if f != result:
+ print('\tfutrig:', f)
+
+ return result
+
+
+def _dotrig(a, b):
+ """Helper to tell whether ``a`` and ``b`` have the same sorts
+ of symbols in them -- no need to test hyperbolic patterns against
+ expressions that have no hyperbolics in them."""
+ return a.func == b.func and (
+ a.has(TrigonometricFunction) and b.has(TrigonometricFunction) or
+ a.has(HyperbolicFunction) and b.has(HyperbolicFunction))
+
+
+_trigpat = None
+def _trigpats():
+ global _trigpat
+ a, b, c = symbols('a b c', cls=Wild)
+ d = Wild('d', commutative=False)
+
+ # for the simplifications like sinh/cosh -> tanh:
+ # DO NOT REORDER THE FIRST 14 since these are assumed to be in this
+ # order in _match_div_rewrite.
+ matchers_division = (
+ (a*sin(b)**c/cos(b)**c, a*tan(b)**c, sin(b), cos(b)),
+ (a*tan(b)**c*cos(b)**c, a*sin(b)**c, sin(b), cos(b)),
+ (a*cot(b)**c*sin(b)**c, a*cos(b)**c, sin(b), cos(b)),
+ (a*tan(b)**c/sin(b)**c, a/cos(b)**c, sin(b), cos(b)),
+ (a*cot(b)**c/cos(b)**c, a/sin(b)**c, sin(b), cos(b)),
+ (a*cot(b)**c*tan(b)**c, a, sin(b), cos(b)),
+ (a*(cos(b) + 1)**c*(cos(b) - 1)**c,
+ a*(-sin(b)**2)**c, cos(b) + 1, cos(b) - 1),
+ (a*(sin(b) + 1)**c*(sin(b) - 1)**c,
+ a*(-cos(b)**2)**c, sin(b) + 1, sin(b) - 1),
+
+ (a*sinh(b)**c/cosh(b)**c, a*tanh(b)**c, S.One, S.One),
+ (a*tanh(b)**c*cosh(b)**c, a*sinh(b)**c, S.One, S.One),
+ (a*coth(b)**c*sinh(b)**c, a*cosh(b)**c, S.One, S.One),
+ (a*tanh(b)**c/sinh(b)**c, a/cosh(b)**c, S.One, S.One),
+ (a*coth(b)**c/cosh(b)**c, a/sinh(b)**c, S.One, S.One),
+ (a*coth(b)**c*tanh(b)**c, a, S.One, S.One),
+
+ (c*(tanh(a) + tanh(b))/(1 + tanh(a)*tanh(b)),
+ tanh(a + b)*c, S.One, S.One),
+ )
+
+ matchers_add = (
+ (c*sin(a)*cos(b) + c*cos(a)*sin(b) + d, sin(a + b)*c + d),
+ (c*cos(a)*cos(b) - c*sin(a)*sin(b) + d, cos(a + b)*c + d),
+ (c*sin(a)*cos(b) - c*cos(a)*sin(b) + d, sin(a - b)*c + d),
+ (c*cos(a)*cos(b) + c*sin(a)*sin(b) + d, cos(a - b)*c + d),
+ (c*sinh(a)*cosh(b) + c*sinh(b)*cosh(a) + d, sinh(a + b)*c + d),
+ (c*cosh(a)*cosh(b) + c*sinh(a)*sinh(b) + d, cosh(a + b)*c + d),
+ )
+
+ # for cos(x)**2 + sin(x)**2 -> 1
+ matchers_identity = (
+ (a*sin(b)**2, a - a*cos(b)**2),
+ (a*tan(b)**2, a*(1/cos(b))**2 - a),
+ (a*cot(b)**2, a*(1/sin(b))**2 - a),
+ (a*sin(b + c), a*(sin(b)*cos(c) + sin(c)*cos(b))),
+ (a*cos(b + c), a*(cos(b)*cos(c) - sin(b)*sin(c))),
+ (a*tan(b + c), a*((tan(b) + tan(c))/(1 - tan(b)*tan(c)))),
+
+ (a*sinh(b)**2, a*cosh(b)**2 - a),
+ (a*tanh(b)**2, a - a*(1/cosh(b))**2),
+ (a*coth(b)**2, a + a*(1/sinh(b))**2),
+ (a*sinh(b + c), a*(sinh(b)*cosh(c) + sinh(c)*cosh(b))),
+ (a*cosh(b + c), a*(cosh(b)*cosh(c) + sinh(b)*sinh(c))),
+ (a*tanh(b + c), a*((tanh(b) + tanh(c))/(1 + tanh(b)*tanh(c)))),
+
+ )
+
+ # Reduce any lingering artifacts, such as sin(x)**2 changing
+ # to 1-cos(x)**2 when sin(x)**2 was "simpler"
+ artifacts = (
+ (a - a*cos(b)**2 + c, a*sin(b)**2 + c, cos),
+ (a - a*(1/cos(b))**2 + c, -a*tan(b)**2 + c, cos),
+ (a - a*(1/sin(b))**2 + c, -a*cot(b)**2 + c, sin),
+
+ (a - a*cosh(b)**2 + c, -a*sinh(b)**2 + c, cosh),
+ (a - a*(1/cosh(b))**2 + c, a*tanh(b)**2 + c, cosh),
+ (a + a*(1/sinh(b))**2 + c, a*coth(b)**2 + c, sinh),
+
+ # same as above but with noncommutative prefactor
+ (a*d - a*d*cos(b)**2 + c, a*d*sin(b)**2 + c, cos),
+ (a*d - a*d*(1/cos(b))**2 + c, -a*d*tan(b)**2 + c, cos),
+ (a*d - a*d*(1/sin(b))**2 + c, -a*d*cot(b)**2 + c, sin),
+
+ (a*d - a*d*cosh(b)**2 + c, -a*d*sinh(b)**2 + c, cosh),
+ (a*d - a*d*(1/cosh(b))**2 + c, a*d*tanh(b)**2 + c, cosh),
+ (a*d + a*d*(1/sinh(b))**2 + c, a*d*coth(b)**2 + c, sinh),
+ )
+
+ _trigpat = (a, b, c, d, matchers_division, matchers_add,
+ matchers_identity, artifacts)
+ return _trigpat
+
+
+def _replace_mul_fpowxgpow(expr, f, g, rexp, h, rexph):
+ """Helper for _match_div_rewrite.
+
+ Replace f(b_)**c_*g(b_)**(rexp(c_)) with h(b)**rexph(c) if f(b_)
+ and g(b_) are both positive or if c_ is an integer.
+ """
+ # assert expr.is_Mul and expr.is_commutative and f != g
+ fargs = defaultdict(int)
+ gargs = defaultdict(int)
+ args = []
+ for x in expr.args:
+ if x.is_Pow or x.func in (f, g):
+ b, e = x.as_base_exp()
+ if b.is_positive or e.is_integer:
+ if b.func == f:
+ fargs[b.args[0]] += e
+ continue
+ elif b.func == g:
+ gargs[b.args[0]] += e
+ continue
+ args.append(x)
+ common = set(fargs) & set(gargs)
+ hit = False
+ while common:
+ key = common.pop()
+ fe = fargs.pop(key)
+ ge = gargs.pop(key)
+ if fe == rexp(ge):
+ args.append(h(key)**rexph(fe))
+ hit = True
+ else:
+ fargs[key] = fe
+ gargs[key] = ge
+ if not hit:
+ return expr
+ while fargs:
+ key, e = fargs.popitem()
+ args.append(f(key)**e)
+ while gargs:
+ key, e = gargs.popitem()
+ args.append(g(key)**e)
+ return Mul(*args)
+
+
+_idn = lambda x: x
+_midn = lambda x: -x
+_one = lambda x: S.One
+
+def _match_div_rewrite(expr, i):
+ """helper for __trigsimp"""
+ if i == 0:
+ expr = _replace_mul_fpowxgpow(expr, sin, cos,
+ _midn, tan, _idn)
+ elif i == 1:
+ expr = _replace_mul_fpowxgpow(expr, tan, cos,
+ _idn, sin, _idn)
+ elif i == 2:
+ expr = _replace_mul_fpowxgpow(expr, cot, sin,
+ _idn, cos, _idn)
+ elif i == 3:
+ expr = _replace_mul_fpowxgpow(expr, tan, sin,
+ _midn, cos, _midn)
+ elif i == 4:
+ expr = _replace_mul_fpowxgpow(expr, cot, cos,
+ _midn, sin, _midn)
+ elif i == 5:
+ expr = _replace_mul_fpowxgpow(expr, cot, tan,
+ _idn, _one, _idn)
+ # i in (6, 7) is skipped
+ elif i == 8:
+ expr = _replace_mul_fpowxgpow(expr, sinh, cosh,
+ _midn, tanh, _idn)
+ elif i == 9:
+ expr = _replace_mul_fpowxgpow(expr, tanh, cosh,
+ _idn, sinh, _idn)
+ elif i == 10:
+ expr = _replace_mul_fpowxgpow(expr, coth, sinh,
+ _idn, cosh, _idn)
+ elif i == 11:
+ expr = _replace_mul_fpowxgpow(expr, tanh, sinh,
+ _midn, cosh, _midn)
+ elif i == 12:
+ expr = _replace_mul_fpowxgpow(expr, coth, cosh,
+ _midn, sinh, _midn)
+ elif i == 13:
+ expr = _replace_mul_fpowxgpow(expr, coth, tanh,
+ _idn, _one, _idn)
+ else:
+ return None
+ return expr
+
+
+def _trigsimp(expr, deep=False):
+ # protect the cache from non-trig patterns; we only allow
+ # trig patterns to enter the cache
+ if expr.has(*_trigs):
+ return __trigsimp(expr, deep)
+ return expr
+
+
+@cacheit
+def __trigsimp(expr, deep=False):
+ """recursive helper for trigsimp"""
+ from sympy.simplify.fu import TR10i
+
+ if _trigpat is None:
+ _trigpats()
+ a, b, c, d, matchers_division, matchers_add, \
+ matchers_identity, artifacts = _trigpat
+
+ if expr.is_Mul:
+ # do some simplifications like sin/cos -> tan:
+ if not expr.is_commutative:
+ com, nc = expr.args_cnc()
+ expr = _trigsimp(Mul._from_args(com), deep)*Mul._from_args(nc)
+ else:
+ for i, (pattern, simp, ok1, ok2) in enumerate(matchers_division):
+ if not _dotrig(expr, pattern):
+ continue
+
+ newexpr = _match_div_rewrite(expr, i)
+ if newexpr is not None:
+ if newexpr != expr:
+ expr = newexpr
+ break
+ else:
+ continue
+
+ # use SymPy matching instead
+ res = expr.match(pattern)
+ if res and res.get(c, 0):
+ if not res[c].is_integer:
+ ok = ok1.subs(res)
+ if not ok.is_positive:
+ continue
+ ok = ok2.subs(res)
+ if not ok.is_positive:
+ continue
+ # if "a" contains any of trig or hyperbolic funcs with
+ # argument "b" then skip the simplification
+ if any(w.args[0] == res[b] for w in res[a].atoms(
+ TrigonometricFunction, HyperbolicFunction)):
+ continue
+ # simplify and finish:
+ expr = simp.subs(res)
+ break # process below
+
+ if expr.is_Add:
+ args = []
+ for term in expr.args:
+ if not term.is_commutative:
+ com, nc = term.args_cnc()
+ nc = Mul._from_args(nc)
+ term = Mul._from_args(com)
+ else:
+ nc = S.One
+ term = _trigsimp(term, deep)
+ for pattern, result in matchers_identity:
+ res = term.match(pattern)
+ if res is not None:
+ term = result.subs(res)
+ break
+ args.append(term*nc)
+ if args != expr.args:
+ expr = Add(*args)
+ expr = min(expr, expand(expr), key=count_ops)
+ if expr.is_Add:
+ for pattern, result in matchers_add:
+ if not _dotrig(expr, pattern):
+ continue
+ expr = TR10i(expr)
+ if expr.has(HyperbolicFunction):
+ res = expr.match(pattern)
+ # if "d" contains any trig or hyperbolic funcs with
+ # argument "a" or "b" then skip the simplification;
+ # this isn't perfect -- see tests
+ if res is None or not (a in res and b in res) or any(
+ w.args[0] in (res[a], res[b]) for w in res[d].atoms(
+ TrigonometricFunction, HyperbolicFunction)):
+ continue
+ expr = result.subs(res)
+ break
+
+ # Reduce any lingering artifacts, such as sin(x)**2 changing
+ # to 1 - cos(x)**2 when sin(x)**2 was "simpler"
+ for pattern, result, ex in artifacts:
+ if not _dotrig(expr, pattern):
+ continue
+ # Substitute a new wild that excludes some function(s)
+ # to help influence a better match. This is because
+ # sometimes, for example, 'a' would match sec(x)**2
+ a_t = Wild('a', exclude=[ex])
+ pattern = pattern.subs(a, a_t)
+ result = result.subs(a, a_t)
+
+ m = expr.match(pattern)
+ was = None
+ while m and was != expr:
+ was = expr
+ if m[a_t] == 0 or \
+ -m[a_t] in m[c].args or m[a_t] + m[c] == 0:
+ break
+ if d in m and m[a_t]*m[d] + m[c] == 0:
+ break
+ expr = result.subs(m)
+ m = expr.match(pattern)
+ m.setdefault(c, S.Zero)
+
+ elif expr.is_Mul or expr.is_Pow or deep and expr.args:
+ expr = expr.func(*[_trigsimp(a, deep) for a in expr.args])
+
+ try:
+ if not expr.has(*_trigs):
+ raise TypeError
+ e = expr.atoms(exp)
+ new = expr.rewrite(exp, deep=deep)
+ if new == e:
+ raise TypeError
+ fnew = factor(new)
+ if fnew != new:
+ new = min([new, factor(new)], key=count_ops)
+ # if all exp that were introduced disappeared then accept it
+ if not (new.atoms(exp) - e):
+ expr = new
+ except TypeError:
+ pass
+
+ return expr
+#------------------- end of old trigsimp routines --------------------
+
+
+def futrig(e, *, hyper=True, **kwargs):
+ """Return simplified ``e`` using Fu-like transformations.
+ This is not the "Fu" algorithm. This is called by default
+ from ``trigsimp``. By default, hyperbolics subexpressions
+ will be simplified, but this can be disabled by setting
+ ``hyper=False``.
+
+ Examples
+ ========
+
+ >>> from sympy import trigsimp, tan, sinh, tanh
+ >>> from sympy.simplify.trigsimp import futrig
+ >>> from sympy.abc import x
+ >>> trigsimp(1/tan(x)**2)
+ tan(x)**(-2)
+
+ >>> futrig(sinh(x)/tanh(x))
+ cosh(x)
+
+ """
+ from sympy.simplify.fu import hyper_as_trig
+
+ e = sympify(e)
+
+ if not isinstance(e, Basic):
+ return e
+
+ if not e.args:
+ return e
+
+ old = e
+ e = bottom_up(e, _futrig)
+
+ if hyper and e.has(HyperbolicFunction):
+ e, f = hyper_as_trig(e)
+ e = f(bottom_up(e, _futrig))
+
+ if e != old and e.is_Mul and e.args[0].is_Rational:
+ # redistribute leading coeff on 2-arg Add
+ e = Mul(*e.as_coeff_Mul())
+ return e
+
+
+def _futrig(e):
+ """Helper for futrig."""
+ from sympy.simplify.fu import (
+ TR1, TR2, TR3, TR2i, TR10, L, TR10i,
+ TR8, TR6, TR15, TR16, TR111, TR5, TRmorrie, TR11, _TR11, TR14, TR22,
+ TR12)
+
+ if not e.has(TrigonometricFunction):
+ return e
+
+ if e.is_Mul:
+ coeff, e = e.as_independent(TrigonometricFunction)
+ else:
+ coeff = None
+
+ Lops = lambda x: (L(x), x.count_ops(), _nodes(x), len(x.args), x.is_Add)
+ trigs = lambda x: x.has(TrigonometricFunction)
+
+ tree = [identity,
+ (
+ TR3, # canonical angles
+ TR1, # sec-csc -> cos-sin
+ TR12, # expand tan of sum
+ lambda x: _eapply(factor, x, trigs),
+ TR2, # tan-cot -> sin-cos
+ [identity, lambda x: _eapply(_mexpand, x, trigs)],
+ TR2i, # sin-cos ratio -> tan
+ lambda x: _eapply(lambda i: factor(i.normal()), x, trigs),
+ TR14, # factored identities
+ TR5, # sin-pow -> cos_pow
+ TR10, # sin-cos of sums -> sin-cos prod
+ TR11, _TR11, TR6, # reduce double angles and rewrite cos pows
+ lambda x: _eapply(factor, x, trigs),
+ TR14, # factored powers of identities
+ [identity, lambda x: _eapply(_mexpand, x, trigs)],
+ TR10i, # sin-cos products > sin-cos of sums
+ TRmorrie,
+ [identity, TR8], # sin-cos products -> sin-cos of sums
+ [identity, lambda x: TR2i(TR2(x))], # tan -> sin-cos -> tan
+ [
+ lambda x: _eapply(expand_mul, TR5(x), trigs),
+ lambda x: _eapply(
+ expand_mul, TR15(x), trigs)], # pos/neg powers of sin
+ [
+ lambda x: _eapply(expand_mul, TR6(x), trigs),
+ lambda x: _eapply(
+ expand_mul, TR16(x), trigs)], # pos/neg powers of cos
+ TR111, # tan, sin, cos to neg power -> cot, csc, sec
+ [identity, TR2i], # sin-cos ratio to tan
+ [identity, lambda x: _eapply(
+ expand_mul, TR22(x), trigs)], # tan-cot to sec-csc
+ TR1, TR2, TR2i,
+ [identity, lambda x: _eapply(
+ factor_terms, TR12(x), trigs)], # expand tan of sum
+ )]
+ e = greedy(tree, objective=Lops)(e)
+
+ if coeff is not None:
+ e = coeff * e
+
+ return e
+
+
+def _is_Expr(e):
+ """_eapply helper to tell whether ``e`` and all its args
+ are Exprs."""
+ if isinstance(e, Derivative):
+ return _is_Expr(e.expr)
+ if not isinstance(e, Expr):
+ return False
+ return all(_is_Expr(i) for i in e.args)
+
+
+def _eapply(func, e, cond=None):
+ """Apply ``func`` to ``e`` if all args are Exprs else only
+ apply it to those args that *are* Exprs."""
+ if not isinstance(e, Expr):
+ return e
+ if _is_Expr(e) or not e.args:
+ return func(e)
+ return e.func(*[
+ _eapply(func, ei) if (cond is None or cond(ei)) else ei
+ for ei in e.args])