|
|
"""Parabolic geometrical entity. |
|
|
|
|
|
Contains |
|
|
* Parabola |
|
|
|
|
|
""" |
|
|
|
|
|
from sympy.core import S |
|
|
from sympy.core.sorting import ordered |
|
|
from sympy.core.symbol import _symbol, symbols |
|
|
from sympy.geometry.entity import GeometryEntity, GeometrySet |
|
|
from sympy.geometry.point import Point, Point2D |
|
|
from sympy.geometry.line import Line, Line2D, Ray2D, Segment2D, LinearEntity3D |
|
|
from sympy.geometry.ellipse import Ellipse |
|
|
from sympy.functions import sign |
|
|
from sympy.simplify.simplify import simplify |
|
|
from sympy.solvers.solvers import solve |
|
|
|
|
|
|
|
|
class Parabola(GeometrySet): |
|
|
"""A parabolic GeometryEntity. |
|
|
|
|
|
A parabola is declared with a point, that is called 'focus', and |
|
|
a line, that is called 'directrix'. |
|
|
Only vertical or horizontal parabolas are currently supported. |
|
|
|
|
|
Parameters |
|
|
========== |
|
|
|
|
|
focus : Point |
|
|
Default value is Point(0, 0) |
|
|
directrix : Line |
|
|
|
|
|
Attributes |
|
|
========== |
|
|
|
|
|
focus |
|
|
directrix |
|
|
axis of symmetry |
|
|
focal length |
|
|
p parameter |
|
|
vertex |
|
|
eccentricity |
|
|
|
|
|
Raises |
|
|
====== |
|
|
ValueError |
|
|
When `focus` is not a two dimensional point. |
|
|
When `focus` is a point of directrix. |
|
|
NotImplementedError |
|
|
When `directrix` is neither horizontal nor vertical. |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import Parabola, Point, Line |
|
|
>>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7,8))) |
|
|
>>> p1.focus |
|
|
Point2D(0, 0) |
|
|
>>> p1.directrix |
|
|
Line2D(Point2D(5, 8), Point2D(7, 8)) |
|
|
|
|
|
""" |
|
|
|
|
|
def __new__(cls, focus=None, directrix=None, **kwargs): |
|
|
|
|
|
if focus: |
|
|
focus = Point(focus, dim=2) |
|
|
else: |
|
|
focus = Point(0, 0) |
|
|
|
|
|
directrix = Line(directrix) |
|
|
|
|
|
if directrix.contains(focus): |
|
|
raise ValueError('The focus must not be a point of directrix') |
|
|
|
|
|
return GeometryEntity.__new__(cls, focus, directrix, **kwargs) |
|
|
|
|
|
@property |
|
|
def ambient_dimension(self): |
|
|
"""Returns the ambient dimension of parabola. |
|
|
|
|
|
Returns |
|
|
======= |
|
|
|
|
|
ambient_dimension : integer |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import Parabola, Point, Line |
|
|
>>> f1 = Point(0, 0) |
|
|
>>> p1 = Parabola(f1, Line(Point(5, 8), Point(7, 8))) |
|
|
>>> p1.ambient_dimension |
|
|
2 |
|
|
|
|
|
""" |
|
|
return 2 |
|
|
|
|
|
@property |
|
|
def axis_of_symmetry(self): |
|
|
"""Return the axis of symmetry of the parabola: a line |
|
|
perpendicular to the directrix passing through the focus. |
|
|
|
|
|
Returns |
|
|
======= |
|
|
|
|
|
axis_of_symmetry : Line |
|
|
|
|
|
See Also |
|
|
======== |
|
|
|
|
|
sympy.geometry.line.Line |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import Parabola, Point, Line |
|
|
>>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8))) |
|
|
>>> p1.axis_of_symmetry |
|
|
Line2D(Point2D(0, 0), Point2D(0, 1)) |
|
|
|
|
|
""" |
|
|
return self.directrix.perpendicular_line(self.focus) |
|
|
|
|
|
@property |
|
|
def directrix(self): |
|
|
"""The directrix of the parabola. |
|
|
|
|
|
Returns |
|
|
======= |
|
|
|
|
|
directrix : Line |
|
|
|
|
|
See Also |
|
|
======== |
|
|
|
|
|
sympy.geometry.line.Line |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import Parabola, Point, Line |
|
|
>>> l1 = Line(Point(5, 8), Point(7, 8)) |
|
|
>>> p1 = Parabola(Point(0, 0), l1) |
|
|
>>> p1.directrix |
|
|
Line2D(Point2D(5, 8), Point2D(7, 8)) |
|
|
|
|
|
""" |
|
|
return self.args[1] |
|
|
|
|
|
@property |
|
|
def eccentricity(self): |
|
|
"""The eccentricity of the parabola. |
|
|
|
|
|
Returns |
|
|
======= |
|
|
|
|
|
eccentricity : number |
|
|
|
|
|
A parabola may also be characterized as a conic section with an |
|
|
eccentricity of 1. As a consequence of this, all parabolas are |
|
|
similar, meaning that while they can be different sizes, |
|
|
they are all the same shape. |
|
|
|
|
|
See Also |
|
|
======== |
|
|
|
|
|
https://en.wikipedia.org/wiki/Parabola |
|
|
|
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import Parabola, Point, Line |
|
|
>>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8))) |
|
|
>>> p1.eccentricity |
|
|
1 |
|
|
|
|
|
Notes |
|
|
----- |
|
|
The eccentricity for every Parabola is 1 by definition. |
|
|
|
|
|
""" |
|
|
return S.One |
|
|
|
|
|
def equation(self, x='x', y='y'): |
|
|
"""The equation of the parabola. |
|
|
|
|
|
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 Parabola, Point, Line |
|
|
>>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8))) |
|
|
>>> p1.equation() |
|
|
-x**2 - 16*y + 64 |
|
|
>>> p1.equation('f') |
|
|
-f**2 - 16*y + 64 |
|
|
>>> p1.equation(y='z') |
|
|
-x**2 - 16*z + 64 |
|
|
|
|
|
""" |
|
|
x = _symbol(x, real=True) |
|
|
y = _symbol(y, real=True) |
|
|
|
|
|
m = self.directrix.slope |
|
|
if m is S.Infinity: |
|
|
t1 = 4 * (self.p_parameter) * (x - self.vertex.x) |
|
|
t2 = (y - self.vertex.y)**2 |
|
|
elif m == 0: |
|
|
t1 = 4 * (self.p_parameter) * (y - self.vertex.y) |
|
|
t2 = (x - self.vertex.x)**2 |
|
|
else: |
|
|
a, b = self.focus |
|
|
c, d = self.directrix.coefficients[:2] |
|
|
t1 = (x - a)**2 + (y - b)**2 |
|
|
t2 = self.directrix.equation(x, y)**2/(c**2 + d**2) |
|
|
return t1 - t2 |
|
|
|
|
|
@property |
|
|
def focal_length(self): |
|
|
"""The focal length of the parabola. |
|
|
|
|
|
Returns |
|
|
======= |
|
|
|
|
|
focal_lenght : number or symbolic expression |
|
|
|
|
|
Notes |
|
|
===== |
|
|
|
|
|
The distance between the vertex and the focus |
|
|
(or the vertex and directrix), measured along the axis |
|
|
of symmetry, is the "focal length". |
|
|
|
|
|
See Also |
|
|
======== |
|
|
|
|
|
https://en.wikipedia.org/wiki/Parabola |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import Parabola, Point, Line |
|
|
>>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8))) |
|
|
>>> p1.focal_length |
|
|
4 |
|
|
|
|
|
""" |
|
|
distance = self.directrix.distance(self.focus) |
|
|
focal_length = distance/2 |
|
|
|
|
|
return focal_length |
|
|
|
|
|
@property |
|
|
def focus(self): |
|
|
"""The focus of the parabola. |
|
|
|
|
|
Returns |
|
|
======= |
|
|
|
|
|
focus : Point |
|
|
|
|
|
See Also |
|
|
======== |
|
|
|
|
|
sympy.geometry.point.Point |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import Parabola, Point, Line |
|
|
>>> f1 = Point(0, 0) |
|
|
>>> p1 = Parabola(f1, Line(Point(5, 8), Point(7, 8))) |
|
|
>>> p1.focus |
|
|
Point2D(0, 0) |
|
|
|
|
|
""" |
|
|
return self.args[0] |
|
|
|
|
|
def intersection(self, o): |
|
|
"""The intersection of the parabola and another geometrical entity `o`. |
|
|
|
|
|
Parameters |
|
|
========== |
|
|
|
|
|
o : GeometryEntity, LinearEntity |
|
|
|
|
|
Returns |
|
|
======= |
|
|
|
|
|
intersection : list of GeometryEntity objects |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import Parabola, Point, Ellipse, Line, Segment |
|
|
>>> p1 = Point(0,0) |
|
|
>>> l1 = Line(Point(1, -2), Point(-1,-2)) |
|
|
>>> parabola1 = Parabola(p1, l1) |
|
|
>>> parabola1.intersection(Ellipse(Point(0, 0), 2, 5)) |
|
|
[Point2D(-2, 0), Point2D(2, 0)] |
|
|
>>> parabola1.intersection(Line(Point(-7, 3), Point(12, 3))) |
|
|
[Point2D(-4, 3), Point2D(4, 3)] |
|
|
>>> parabola1.intersection(Segment((-12, -65), (14, -68))) |
|
|
[] |
|
|
|
|
|
""" |
|
|
x, y = symbols('x y', real=True) |
|
|
parabola_eq = self.equation() |
|
|
if isinstance(o, Parabola): |
|
|
if o in self: |
|
|
return [o] |
|
|
else: |
|
|
return list(ordered([Point(i) for i in solve( |
|
|
[parabola_eq, o.equation()], [x, y], set=True)[1]])) |
|
|
elif isinstance(o, Point2D): |
|
|
if simplify(parabola_eq.subs([(x, o._args[0]), (y, o._args[1])])) == 0: |
|
|
return [o] |
|
|
else: |
|
|
return [] |
|
|
elif isinstance(o, (Segment2D, Ray2D)): |
|
|
result = solve([parabola_eq, |
|
|
Line2D(o.points[0], o.points[1]).equation()], |
|
|
[x, y], set=True)[1] |
|
|
return list(ordered([Point2D(i) for i in result if i in o])) |
|
|
elif isinstance(o, (Line2D, Ellipse)): |
|
|
return list(ordered([Point2D(i) for i in solve( |
|
|
[parabola_eq, o.equation()], [x, y], set=True)[1]])) |
|
|
elif isinstance(o, LinearEntity3D): |
|
|
raise TypeError('Entity must be two dimensional, not three dimensional') |
|
|
else: |
|
|
raise TypeError('Wrong type of argument were put') |
|
|
|
|
|
@property |
|
|
def p_parameter(self): |
|
|
"""P is a parameter of parabola. |
|
|
|
|
|
Returns |
|
|
======= |
|
|
|
|
|
p : number or symbolic expression |
|
|
|
|
|
Notes |
|
|
===== |
|
|
|
|
|
The absolute value of p is the focal length. The sign on p tells |
|
|
which way the parabola faces. Vertical parabolas that open up |
|
|
and horizontal that open right, give a positive value for p. |
|
|
Vertical parabolas that open down and horizontal that open left, |
|
|
give a negative value for p. |
|
|
|
|
|
|
|
|
See Also |
|
|
======== |
|
|
|
|
|
https://www.sparknotes.com/math/precalc/conicsections/section2/ |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import Parabola, Point, Line |
|
|
>>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8))) |
|
|
>>> p1.p_parameter |
|
|
-4 |
|
|
|
|
|
""" |
|
|
m = self.directrix.slope |
|
|
if m is S.Infinity: |
|
|
x = self.directrix.coefficients[2] |
|
|
p = sign(self.focus.args[0] + x) |
|
|
elif m == 0: |
|
|
y = self.directrix.coefficients[2] |
|
|
p = sign(self.focus.args[1] + y) |
|
|
else: |
|
|
d = self.directrix.projection(self.focus) |
|
|
p = sign(self.focus.x - d.x) |
|
|
return p * self.focal_length |
|
|
|
|
|
@property |
|
|
def vertex(self): |
|
|
"""The vertex of the parabola. |
|
|
|
|
|
Returns |
|
|
======= |
|
|
|
|
|
vertex : Point |
|
|
|
|
|
See Also |
|
|
======== |
|
|
|
|
|
sympy.geometry.point.Point |
|
|
|
|
|
Examples |
|
|
======== |
|
|
|
|
|
>>> from sympy import Parabola, Point, Line |
|
|
>>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8))) |
|
|
>>> p1.vertex |
|
|
Point2D(0, 4) |
|
|
|
|
|
""" |
|
|
focus = self.focus |
|
|
m = self.directrix.slope |
|
|
if m is S.Infinity: |
|
|
vertex = Point(focus.args[0] - self.p_parameter, focus.args[1]) |
|
|
elif m == 0: |
|
|
vertex = Point(focus.args[0], focus.args[1] - self.p_parameter) |
|
|
else: |
|
|
vertex = self.axis_of_symmetry.intersection(self)[0] |
|
|
return vertex |
|
|
|
