Add files using upload-large-folder tool

.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

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

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

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

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

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

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]]: ...

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

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

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',
+]

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)

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 (
+            '<ellipse fill="{1}" stroke="#555555" '
+            'stroke-width="{0}" opacity="0.6" cx="{2}" cy="{3}" rx="{4}" ry="{5}"/>'
+        ).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

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 = '''<svg xmlns="http://www.w3.org/2000/svg"
+            xmlns:xlink="http://www.w3.org/1999/xlink"
+            width="{1}" height="{2}" viewBox="{0}"
+            preserveAspectRatio="xMinYMin meet">
+            <defs>
+                <marker id="markerCircle" markerWidth="8" markerHeight="8"
+                    refx="5" refy="5" markerUnits="strokeWidth">
+                    <circle cx="5" cy="5" r="1.5" style="stroke: none; fill:#000000;"/>
+                </marker>
+                <marker id="markerArrow" markerWidth="13" markerHeight="13" refx="2" refy="4"
+                       orient="auto" markerUnits="strokeWidth">
+                    <path d="M2,2 L2,6 L6,4" style="fill: #000000;" />
+                </marker>
+                <marker id="markerReverseArrow" markerWidth="13" markerHeight="13" refx="6" refy="4"
+                       orient="auto" markerUnits="strokeWidth">
+                    <path d="M6,2 L6,6 L2,4" style="fill: #000000;" />
+                </marker>
+            </defs>'''
+
+        # Establish SVG canvas that will fit all the data + small space
+        xmin, ymin, xmax, ymax = map(N, bounds)
+        if xmin == xmax and ymin == ymax:
+            # This is a point; buffer using an arbitrary size
+            xmin, ymin, xmax, ymax = xmin - .5, ymin -.5, xmax + .5, ymax + .5
+        else:
+            # Expand bounds by a fraction of the data ranges
+            expand = 0.1  # or 10%; this keeps arrowheads in view (R plots use 4%)
+            widest_part = max([xmax - xmin, ymax - ymin])
+            expand_amount = widest_part * expand
+            xmin -= expand_amount
+            ymin -= expand_amount
+            xmax += expand_amount
+            ymax += expand_amount
+        dx = xmax - xmin
+        dy = ymax - ymin
+        width = min([max([100., dx]), 300])
+        height = min([max([100., dy]), 300])
+
+        scale_factor = 1. if max(width, height) == 0 else max(dx, dy) / max(width, height)
+        try:
+            svg = self._svg(scale_factor)
+        except (NotImplementedError, TypeError):
+            # if we have no SVG representation, return None so IPython
+            # will fall back to the next representation
+            return None
+
+        view_box = "{} {} {} {}".format(xmin, ymin, dx, dy)
+        transform = "matrix(1,0,0,-1,0,{})".format(ymax + ymin)
+        svg_top = svg_top.format(view_box, width, height)
+
+        return svg_top + (
+            '<g transform="{}">{}</g></svg>'
+            ).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

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

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 (
+            '<path fill-rule="evenodd" fill="{2}" stroke="#555555" '
+            'stroke-width="{0}" opacity="0.6" d="{1}" '
+            'marker-start="url(#markerCircle)" marker-end="url(#markerArrow)"/>'
+        ).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 (
+            '<path fill-rule="evenodd" fill="{2}" stroke="#555555" '
+            'stroke-width="{0}" opacity="0.6" d="{1}" '
+            'marker-start="url(#markerReverseArrow)" marker-end="url(#markerArrow)"/>'
+        ).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 (
+            '<path fill-rule="evenodd" fill="{2}" stroke="#555555" '
+            'stroke-width="{0}" opacity="0.6" d="{1}" />'
+        ).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)

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

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]

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 (
+            '<path fill-rule="evenodd" fill="{2}" stroke="#555555" '
+            'stroke-width="{0}" opacity="0.6" d="{1}" />'
+            ).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)

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)

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

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

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

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