ó
    ‰*£h5�  ã                   ó.  • S r SSKrSSKJrJrJr  SSKJr  SSKJ	r	  SSK
Jr  SSKJr  SSKJrJr  SS	KJr  SS
KJr  SSKJr  SSKJrJr  SSKJr  SSKJr  SSKJrJ r   SSK!J"r"J#r#J$r$  SSK%J&r&  SSK'J(r(   " S S\&5      r) " S S\)5      r* " S S\)5      r+g)aD  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

é    N)ÚSÚsympifyÚExpr)ÚAdd)ÚTuple)ÚFloat)Úglobal_parameters)Ú	nsimplifyÚsimplify)ÚGeometryError)Úsqrt)Úim)ÚcosÚsin)ÚMatrix)Ú	Transpose)ÚuniqÚis_sequence)Ú
filldedentÚ	func_nameÚUndecidableé   )ÚGeometryEntity)Úprec_to_dpsc                   óf  • \ rS rSrSrSrS rS rS rS r	S r
S	 rS
 rS rS rS rS rS rS rS r\S 5       r\S 5       r\S 5       r\S 5       rS rS rS rS*S jrS rS r S r!\S 5       r"S r#\S 5       r$\S  5       r%S! r&\S" 5       r'\S# 5       r(\S$ 5       r)S% r*S& r+\S' 5       r,S(r-g))+ÚPointé*   a  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)

Tc                 óî  • UR                  S[        R                  5      nUR                  SS5      n[        U5      S:X  a  US   OUn[	        U[
        5      (       a,  Sn[        U5      UR                  S[        U5      5      :X  a  U$ [        U5      (       d,  [        [        SR                  [        U5      5      5      5      e[        U5      S:X  a:  UR                  SS 5      (       a#  [        R                  4UR                  S5      -  n[        U6 nUR                  S[        U5      5      n[        U5      S	:  a  [        [        S
5      5      e[        U5      U:w  ad  SR                  U[        U5      U5      nUS:X  a  OAUS:X  a  [        U5      eUS:X  a  [        R                   " US	S9  O[        [        S5      5      e[#        XVS  5      (       a  [        S5      e[#        S U 5       5      (       a  [        S5      e[%        S U 5       5      (       d  [        S5      eUS U [        R                  4U[        U5      -
  -  -   nU(       aG  UR'                  UR)                  [*        5       Vs0 s H  nU[-        [/        USS95      _M     sn5      n[        U5      S	:X  a  SUS'   [1        U0 UD6$ [        U5      S:X  a  SUS'   [3        U0 UD6$ [4        R6                  " U /UQ76 $ s  snf )NÚevaluateÚon_morphÚignorer   r   FÚdimz<
                Expecting sequence of coordinates, not `{}`é   z[
                Point requires 2 or more coordinates or
                keyword `dim` > 1.z2Dimension of {} needs to be changed from {} to {}.ÚerrorÚwarn)Ú
stacklevelzf
                        on_morph value should be 'error',
                        'warn' or 'ignore'.z&Nonzero coordinates cannot be removed.c              3   ót   #   • U  H.  oR                   =(       a    [        U5      R                  S L v •  M0     g7f)FN)Ú	is_numberr   Úis_zero©Ú.0Úas     ÚQ/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sympy/geometry/point.pyÚ	<genexpr>Ú Point.__new__.<locals>.<genexpr>›   s'   é € ÐFºv¸!�{‰{×5œr !›uŸ}™}°Ð5Ô5ºvùs   ‚68z(Imaginary coordinates are not permitted.c              3   óB   #   • U  H  n[        U[        5      v •  M     g 7f©N)Ú
isinstancer   r*   s     r-   r.   r/   �   s   é € Ð7²¨1”:˜a¤×&Ð&²ùs   ‚z,Coordinates must be valid SymPy expressions.T)ÚrationalÚ_nochecké   )Úgetr	   r   Úlenr2   r   r   Ú	TypeErrorr   Úformatr   r   ÚZeror   Ú
ValueErrorÚwarningsr%   ÚanyÚallÚxreplaceÚatomsr   r   r
   ÚPoint2DÚPoint3Dr   Ú__new__)	ÚclsÚargsÚkwargsr   r    Úcoordsr"   ÚmessageÚfs	            r-   rC   ÚPoint.__new__m   sË  € Ø—:‘:˜jÔ*;×*DÑ*DÓEˆØ—:‘:˜j¨(Ó3ˆô   ›I¨›N��a’°ˆô �fœe×$Ñ$ð ˆHÜ�6‹{˜fŸj™j¨´°F³Ó<Ó<Ø�ä˜6×"Ñ"ÜœJð (?ç(.©¬y¸Ó/@Ó(AóCó Dð Dô
 ˆv‹;˜!Ó §
¡
¨5°$× 7Ñ 7Ü—f‘f�Y˜vŸz™z¨%Ó0Ñ0ˆFä˜�ˆØ�j‰j˜¤ F£Ó,ˆäˆv‹;˜‹?ÜœZð )&ó 'ó (ð (ô ˆv‹;˜#Óð(ß)/©°¼¸F»ÀSÓ)Ið à˜8Ó#ØØ˜WÓ$Ü  Ó)Ð)Ø˜VÓ#Ü—’˜g°!Ó4ä ¤ð -/ó "0ó 1ð 1ô ˆv�dˆ|×ÑÜÐEÓFÐFÜÑF¹vÓF×FÑFÜÐGÓHÐHÜÑ7±Ó7×7Ñ7ÜÐJÓKÐKð ˜˜�¤§¡ 	¨3´°V³Ñ+<Ñ =Ñ=ˆö Ø—_‘_à Ÿ,™,¤uÔ-ó&/â-�Qð ”8œI a°$Ñ7Ó8Ò8Ù-ñ&/ó 0ˆFô
 ˆv‹;˜!ÓØ!%ˆF�:ÑÜ˜FÐ- fÑ-Ð-Ü�‹[˜AÓØ!%ˆF�:ÑÜ˜FÐ- fÑ-Ð-ô ×%Ò% cÐ3¨FÒ3Ð3ùò&/s   É8K2c                 ó\   • [        S/[        U 5      -  5      n[         R                  X5      $ )z7Returns the distance between this point and the origin.r   )r   r7   Údistance)ÚselfÚorigins     r-   Ú__abs__ÚPoint.__abs__µ   s%   € ä˜�sœ3˜t›9‘}Ó%ˆÜ�~‰~˜fÓ+Ð+ó    c                 ó  •  [         R                  U [        USS95      u  p#[        X#5       VVs/ s H  u  pE[        XE-   5      PM     nnn[        USS9$ ! [         a    [        SR	                  U5      5      ef = fs  snnf )a˜  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

F©r   z+Don't know how to add {} and a Point object)r   Ú_normalize_dimensionr8   r   r9   Úzipr   )rM   ÚotherÚsÚor,   ÚbrG   s          r-   Ú__add__ÚPoint.__add__º   s�   € ð>	]Ü×-Ñ-¨d´E¸%È%Ñ4PÓQ‰DˆAô /2°!¬iÔ8ªi¡d a”(˜1™5–/©iˆÑ8Ü�V eÑ,Ð,øô	 ó 	]ÜÐ M× TÑ TÐUZÓ [Ó\Ð\ð	]üó 9s   ‚ A °A>Á%A;c                 ó   • XR                   ;   $ r1   ©rE   ©rM   Úitems     r-   Ú__contains__ÚPoint.__contains__á   s   € Ø—y‘yÑ Ð rQ   c                 ó„   • [        U5      nU R                   Vs/ s H  n[        X!-  5      PM     nn[        USS9$ s  snf )z'Divide point's coordinates by a factor.FrS   ©r   rE   r   r   )rM   ÚdivisorÚxrG   s       r-   Ú__truediv__ÚPoint.__truediv__ä   s=   € ä˜'Ó"ˆØ/3¯yªyÓ9ªy¨!”(˜1™9Ö%©yˆÐ9Ü�V eÑ,Ð,ùò :ó   š=c                 ó¸   • [        U[        5      (       a,  [        U R                  5      [        UR                  5      :w  a  gU R                  UR                  :H  $ )NF)r2   r   r7   rE   ©rM   rV   s     r-   Ú__eq__ÚPoint.__eq__ê   s<   € Ü˜%¤×'Ñ'¬3¨t¯y©y«>¼SÀÇÁ»_Ó+LØØ�y‰y˜EŸJ™JÑ&Ð&rQ   c                 ó    • U R                   U   $ r1   r]   )rM   Úkeys     r-   Ú__getitem__ÚPoint.__getitem__ï   s   € Ø�y‰y˜‰~ÐrQ   c                 ó,   • [        U R                  5      $ r1   )ÚhashrE   ©rM   s    r-   Ú__hash__ÚPoint.__hash__ò   s   € Ü�D—I‘I‹ÐrQ   c                 ó6   • U R                   R                  5       $ r1   )rE   Ú__iter__rs   s    r-   rw   ÚPoint.__iter__õ   s   € Ø�y‰y×!Ñ!Ó#Ð#rQ   c                 ó,   • [        U R                  5      $ r1   )r7   rE   rs   s    r-   Ú__len__ÚPoint.__len__ø   s   € Ü�4—9‘9‹~ÐrQ   c                 ó„   • [        U5      nU R                   Vs/ s H  n[        X!-  5      PM     nn[        USS9$ s  snf )aä  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
FrS   rc   )rM   Úfactorre   rG   s       r-   Ú__mul__ÚPoint.__mul__û   s>   € ô6 ˜“ˆØ.2¯iªiÓ8ªi¨”(˜1™8Ö$©iˆÐ8Ü�V eÑ,Ð,ùò 9rh   c                 ó$   • U R                  U5      $ )z)Multiply a factor by point's coordinates.)r~   )rM   r}   s     r-   Ú__rmul__ÚPoint.__rmul__  s   € à�|‰|˜FÓ#Ð#rQ   c                 óX   • U R                    Vs/ s H  o* PM     nn[        USS9$ s  snf )zNegate the point.FrS   )rE   r   )rM   re   rG   s      r-   Ú__neg__ÚPoint.__neg__  s,   € à"ŸišiÓ(ši˜“"™iˆÐ(Ü�V eÑ,Ð,ùò )s   �'c                 ó6   • X Vs/ s H  o"* PM     sn-   $ s  snf )zHSubtract two points, or subtract a factor from this point's
coordinates.© )rM   rV   re   s      r-   Ú__sub__ÚPoint.__sub__#  s!   € ð  5Ó)¢5˜a“r¡5Ñ)Ñ)Ð)ùÒ)s   …c                 ó.  ^• [        U SS5      mUR                  ST5      mTc  [        S U 5       5      m[        U4S jU 5       5      (       a  [	        U5      $ TUS'   UR                  SS5      US'   U Vs/ s H  n[        U40 UD6PM     sn$ s  snf )znEnsure that points have the same dimension.
By default `on_morph='warn'` is passed to the
`Point` constructor.Ú_ambient_dimensionNr"   c              3   ó8   #   • U  H  oR                   v •  M     g 7fr1   ©Úambient_dimension©r+   Úis     r-   r.   Ú-Point._normalize_dimension.<locals>.<genexpr>3  s   é € Ð:²6¨a×)Ö)²6ùs   ‚c              3   ó@   >#   • U  H  oR                   T:H  v •  M     g 7fr1   r�   )r+   r�   r"   s     €r-   r.   r‘   4  s   øé € Ð:²6¨a×"Ñ" cÖ)²6ùs   ƒr    r%   )Úgetattrr6   Úmaxr>   Úlistr   )rD   ÚpointsrF   r�   r"   s       @r-   rT   ÚPoint._normalize_dimension(  s”   ø€ ô �cÐ/°Ó6ˆà�j‰j˜ Ó$ˆà‰;ÜÑ:±6Ó:Ó:ˆCÜÔ:±6Ó:×:Ñ:Ü˜“<ÐØˆˆu‰Ø#ŸZ™Z¨
°FÓ;ˆˆzÑÙ,2Ó3ªF q”�aÑ"˜6Ô"©FÑ3Ð3ùÒ3s   Á9Bc                  ó<  • [        U 5      S:X  a  g[        R                  " U  Vs/ s H  n[        U5      PM     sn6 nUS   nUSS  Vs/ s H  oU-
  PM	     nn[        U Vs/ s H  oR                  PM     sn5      nUR                  S S9$ s  snf s  snf s  snf )a?  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.r   éÿÿÿÿr   Nc                 óv   • U R                   (       a  [        U R                  S5      5      S:  $ U R                  $ )Nr#   gê-�™—q=)r(   ÚabsÚnr)   )re   s    r-   Ú<lambda>Ú#Point.affine_rank.<locals>.<lambda>M  s(   € Ø#$§;§;ŒC�—‘�A“‹K˜%ÑÐ=°A·I±IÐ=rQ   )Ú
iszerofunc)r7   r   rT   r   rE   Úrank)rE   r�   r–   rN   Úms        r-   Úaffine_rankÚPoint.affine_rank:  s›   € ô ˆt‹9˜‹>Øô ×+Ò+ÁÓ-EÂ¸1¬e°A®hÁÑ-EÐFˆØ˜‘ˆØ&,¨Q¨R¡jÓ1¢j �f”*¡jˆÐ1ä¡FÓ+¢F˜q—F”F¡FÑ+Ó,ˆà�v‰vñ $>ˆvð ?ð 	?ùò .Fùâ1ùâ+s   ¥BÁ
BÁ#Bc                 ó.   • [        U S[        U 5      5      $ )z$Number of components this point has.r‹   )r“   r7   rs   s    r-   rŽ   ÚPoint.ambient_dimensionP  s   € ô �tÐ1´3°t³9Ó=Ð=rQ   c                 óú   • [        U5      S::  a  gU R                  " U Vs/ s H  n[        U5      PM     sn6 nUS   R                  S:X  a  g[	        [        U5      5      n[        R                  " U6 S:*  $ s  snf )a1  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

r   Tr   r#   )r7   rT   r   rŽ   r•   r   r¢   )rD   r–   r�   s      r-   Úare_coplanarÚPoint.are_coplanarU  sv   € ôH ˆv‹;˜!ÓØà×)Ò)¹fÓ+Eºf¸¬E°!®H¹fÑ+EÐFˆà�!‰9×&Ñ&¨!Ó+ØÜ”d˜6“lÓ#ˆÜ× Ò  &Ð)¨QÑ.Ð.ùò ,Fs   ¡A8c           	      óª  • [        U[        5      (       d   [        XR                  S9n[        U[        5      (       aB  [        R                  U [        U5      5      u  p#[        [        S [        X#5       5       6 5      $ [        USS5      nUc  [	        S[        U5      -  5      eU" U 5      $ ! [         a    [	        S[        U5      -  5      ef = f)aª  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)

©r"   z'not recognized as a GeometricEntity: %sc              3   ó4   #   • U  H  u  pX-
  S -  v •  M     g7f©r#   Nr‡   ©r+   r,   rY   s      r-   r.   Ú!Point.distance.<locals>.<genexpr>±  s   é € Ð?²Y©T¨Q˜q™u qžj²Yùs   ‚rL   Nz,distance between Point and %s is not defined)r2   r   r   rŽ   r8   ÚtyperT   r   r   rU   r“   )rM   rV   rW   ÚprL   s        r-   rL   ÚPoint.distanceƒ  sÆ   € ôN ˜%¤×0Ñ0ðYÜ˜e×)?Ñ)?Ñ@�ô �eœU×#Ñ#Ü×-Ñ-¨d´E¸%³LÓA‰DˆAÜœÑ?´S¸´YÓ?Ð@ÓAÐAÜ˜5 *¨dÓ3ˆØÑÜÐJÌTÐRWË[ÑXÓYÐYÙ˜‹~Ðøô ó YÜÐ IÌDÐQVËKÑ WÓXÐXðYús   —B0 Â0"Cc                 óh   • [        U5      (       d  [        U5      n[        S [        X5       5       6 $ )z.Return dot product of self with another Point.c              3   ó.   #   • U  H  u  pX-  v •  M     g 7fr1   r‡   r­   s      r-   r.   ÚPoint.dot.<locals>.<genexpr>»  s   é € Ð2¢\™T˜Q�Q–S¢\ùs   ‚)r   r   r   rU   )rM   r°   s     r-   ÚdotÚ	Point.dot·  s)   € ä˜1�~‰~Ü�a“ˆAÜÑ2¤S¨¤\Ó2Ð3Ð3rQ   c                 ó”   • [        U[        5      (       a  [        U 5      [        U5      :w  a  g[        S [	        X5       5       5      $ )z8Returns whether the coordinates of self and other agree.Fc              3   óH   #   • U  H  u  pUR                  U5      v •  M     g 7fr1   )Úequalsr­   s      r-   r.   ÚPoint.equals.<locals>.<genexpr>Â  s   é € Ð<Ò+;¡4 1�1—8‘8˜A—;�;Ò+;ùs   ‚ ")r2   r   r7   r>   rU   rj   s     r-   r¹   ÚPoint.equals½  s9   € ô ˜%¤×'Ñ'¬3¨t«9¼¸E»
Ó+BØÜÑ<¬3¨tÔ+;Ó<Ó<Ð<rQ   c                 ó’   • [        U5      nU R                   Vs/ s H  oDR                  " SSU0UD6PM     nn[        USS06$ s  snf )a¶  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)

rœ   r   Fr‡   )r   rE   Úevalfr   )rM   ÚprecÚoptionsÚdpsre   rG   s         r-   Ú_eval_evalfÚPoint._eval_evalfÄ  sK   € ô8 ˜$ÓˆØ59·Y²YÓ?²Y°—'’'Ñ+˜CÐ+ 7Ô+±YˆÐ?Ü�fÐ- uÑ-Ð-ùò @s   šAc                 óê   • [        U[        5      (       d  [        U5      n[        U[        5      (       a.  X:X  a  U /$ [        R                  X5      u  p#X :X  a  X#:X  a  U /$ / $ UR	                  U 5      $ )aä  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)]

)r2   r   r   rT   Úintersection)rM   rV   Úp1Úp2s       r-   rÄ   ÚPoint.intersectionä  sk   € ô< ˜%¤×0Ñ0Ü˜%“LˆEÜ�eœU×#Ñ#Ø‹}Ø�v�Ü×/Ñ/°Ó<‰FˆBØ‹z˜b›hØ�v�ØˆIØ×!Ñ! $Ó'Ð'rQ   c                 óÆ   • U 4U-   n[         R                  " U Vs/ s H  n[        U5      PM     sn6 n[        [        U5      5      n[         R                  " U6 S:*  $ s  snf )a+  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

r   )r   rT   r•   r   r¢   )rM   rE   r–   r�   s       r-   Úis_collinearÚPoint.is_collinear  s]   € ðB �˜4‘ˆÜ×+Ò+ÁÓ-GÂ¸1¬e°A®hÁÑ-GÐHˆÜ”d˜6“lÓ#ˆÜ× Ò  &Ð)¨QÑ.Ð.ùò .Hs   ›Ac           	      óÆ  • U 4U-   n[         R                  " U Vs/ s H  n[        U5      PM     sn6 n[        [        U5      5      n[         R                  " U6 S::  d  gUS   nU Vs/ s H  oUU-
  PM	     nn[        U Vs/ s H!  n[        U5      UR                  U5      /-   PM#     sn5      nUR                  5       u  px[        U5      U;  a  ggs  snf s  snf s  snf )ag  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

r#   Fr   T)	r   rT   r•   r   r¢   r   rµ   Úrrefr7   )	rM   rE   r–   r�   rN   r°   ÚmatrÌ   Úpivotss	            r-   Úis_concyclicÚPoint.is_concyclic3  sÓ   € ðL �˜4‘ˆÜ×+Ò+ÁÓ-GÂ¸1¬e°A®hÁÑ-GÐHˆÜ”d˜6“lÓ#ˆÜ× Ò  &Ð)¨QÓ.ØØ˜‘ˆÙ&,Ó-¢f �f”*¡fˆÐ-ô ±FÓ;²F¨q”d˜1“g §¡ q£ 
Ô*±FÑ;Ó<ˆØ—x‘x“z‰ˆÜˆv‹;˜fÓ$ØØùò .Hùò
 .ùò <s   ›CÁ)CÂ(Cc                 ó0   • U R                   nUc  gU(       + $ )zjTrue if any coordinate is nonzero, False if every coordinate is zero,
and None if it cannot be determined.N)r)   )rM   r)   s     r-   Ú
is_nonzeroÚPoint.is_nonzerok  s   € ð —,‘,ˆØ‰?ØØŒ{ÐrQ   c                 ót  • [         R                  U [        U5      5      u  p#UR                  S:X  aT  UR                  UR                  su  pEu  pgXG-  Xe-  -
  R	                  S5      nUc  [        [        SU< SU< 35      5      e[        UR                  UR                  /5      n	U	R                  5       S:  $ )zkReturns whether each coordinate of `self` is a scalar
multiple of the corresponding coordinate in point p.
r#   r   zCannot determine if z- is a scalar multiple of
                    )	r   rT   rŽ   rE   r¹   r   r   r   r    )
rM   r°   rW   rX   Úx1Úy1Úx2Úy2Úrvr¡   s
             r-   Úis_scalar_multipleÚPoint.is_scalar_multiplet  s¦   € ô ×)Ñ)¨$´°a³Ó9‰ˆà×Ñ !Ó#Ø!"§¡¨¯©Ð‰HˆR‘h�rØ‘%˜"™%‘-×'Ñ'¨Ó*ˆBØ‰zÜ!¥*ã¢ð#ó#$ó %ð %ô �A—F‘F˜AŸF™FÐ#Ó$ˆØ�v‰v‹x˜!‰|ÐrQ   c                 óª   • U R                    Vs/ s H  oR                  PM     nn[        U5      (       a  g[        S U 5       5      (       a  ggs  snf )zkTrue if every coordinate is zero, False if any coordinate is not zero,
and None if it cannot be determined.Fc              3   ó(   #   • U  H  oS L v •  M
     g 7fr1   r‡   )r+   re   s     r-   r.   Ú Point.is_zero.<locals>.<genexpr>Ž  s   é € Ð*¢'˜Q�D�y¢'ùs   ‚NT)rE   rÒ   r=   )rM   re   Únonzeros      r-   r)   ÚPoint.is_zero‡  sF   € ð *.¯ªÓ3ª A—<”<©ˆÐ3Üˆw�<‰<ØÜÑ*¡'Ó*×*Ñ*ØØùò 4s   �Ac                 ó"   • [         R                  $ )zš
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
)r   r:   rs   s    r-   ÚlengthÚPoint.length’  s   € ô �v‰vˆrQ   c           
      óÚ   • [         R                  U [        U5      5      u  p![        [        X!5       VVs/ s H#  u  p4[        X4-   [        R
                  -  5      PM%     snn5      $ s  snnf )a  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)

)r   rT   rU   r   r   ÚHalf)rM   r°   rW   r,   rY   s        r-   ÚmidpointÚPoint.midpoint¡  sN   € ô6 ×)Ñ)¨$´°a³Ó9‰ˆÜ¼3¸q¼9ÔEº9±4°1”h ¡¤q§v¡v™~Ö.¹9ÒEÓFÐFùÓEs   µ*A'
c                 ó0   • [        S/[        U 5      -  SS9$ )zGA point of all zeros of the same ambient dimension
as the current pointr   FrS   )r   r7   rs   s    r-   rN   ÚPoint.origin¿  s   € ô �a�Sœ˜T›‘]¨UÑ3Ð3rQ   c                 ó   • U R                   nU S   R                  (       a  [        S/US-
  S/-  -   5      $ U S   R                  (       a  [        SS/US-
  S/-  -   5      $ [        U S   * U S   /US-
  S/-  -   5      $ )a  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
r   r   r#   )rŽ   r)   r   )rM   r"   s     r-   Úorthogonal_directionÚPoint.orthogonal_directionÅ  sŠ   € ð  ×$Ñ$ˆà�‰7�?�?Ü˜!˜  a¡¨!¨™}Ñ,Ó-Ð-Ø�‰7�?�?Ü˜!˜A˜ #¨¡'¨A¨3¡Ñ.Ó/Ð/ô �t˜A‘w�h  Q¡Ð(¨C°!©G°a°S©=Ñ8Ó9Ð9rQ   c                 óØ   • [         R                  [        U 5      [        U5      5      u  pUR                  (       a  [        S5      eXR	                  U5      UR	                  U5      -  -  $ )aÊ  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
ú"Cannot project to the zero vector.)r   rT   r)   r;   rµ   )r,   rY   s     r-   ÚprojectÚPoint.projectß  sR   € ôD ×)Ñ)¬%°«(´E¸!³HÓ=‰ˆØ�9�9ÜÐAÓBÐBØ—%‘%˜“(˜QŸU™U 1›XÑ%Ñ&Ð&rQ   c                 ót   • [         R                  U [        U5      5      u  p![        S [        X!5       5       6 $ )a¢  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

c              3   ó@   #   • U  H  u  p[        X-
  5      v •  M     g 7fr1   ©r›   r­   s      r-   r.   Ú)Point.taxicab_distance.<locals>.<genexpr>%  s   é € Ð6ªI¡D A”S˜™—Z�ZªIùs   ‚)r   rT   r   rU   ©rM   r°   rW   s      r-   Útaxicab_distanceÚPoint.taxicab_distance  s1   € ô< ×)Ñ)¨$´°a³Ó9‰ˆÜÑ6¬C°¬IÓ6Ð7Ð7rQ   c                 óÎ   • [         R                  U [        U5      5      u  p!U R                  (       a  UR                  (       a  [        S5      e[	        S [        X!5       5       6 $ )am  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

rî   c              3   óp   #   • U  H,  u  p[        X-
  5      [        U5      [        U5      -   -  v •  M.     g 7fr1   ró   r­   s      r-   r.   Ú*Point.canberra_distance.<locals>.<genexpr>S  s)   é € ÐJÂ	¹¸”c˜!™%“j¤# a£&¬3¨q«6¡/Ö2Â	ùs   ‚46)r   rT   r)   r;   r   rU   rõ   s      r-   Úcanberra_distanceÚPoint.canberra_distance'  sK   € ôR ×)Ñ)¨$´°a³Ó9‰ˆØ�<�<˜AŸIŸIÜÐAÓBÐBÜÑJÄÀAÄ	ÓJÐKÐKrQ   c                 ó   • U [        U 5      -  $ )z\Return the Point that is in the same direction as `self`
and a distance of 1 from the originró   rs   s    r-   ÚunitÚ
Point.unitU  s   € ð ”c˜$“iÑÐrQ   r‡   N)é   ).Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__Úis_PointrC   rO   rZ   r`   rf   rk   ro   rt   rw   rz   r~   r�   r„   rˆ   ÚclassmethodrT   Ústaticmethodr¢   ÚpropertyrŽ   r§   rL   rµ   r¹   rÁ   rÄ   rÉ   rÏ   rÒ   rÚ   r)   râ   ræ   rN   rë   rï   rö   rû   rþ   Ú__static_attributes__r‡   rQ   r-   r   r   *   sv  † ñ>ð@ €HòF4òP,ò
%-òN!ò-ò'ò
òò$òò-ò>$ò-ò
*ð
 ñ4ó ð4ð" ñ?ó ð?ð* ñ>ó ð>ð ñ+/ó ð+/òZ2òh4ò=ô.ò@'(òR$/òL6ðp ñó ðòð& ñó ðð ñó ðòGð< ñ4ó ð4ð
 ñ:ó ð:ð2 ñ$'ó ð$'òL8òB,Lð\ ñ ó ó rQ   r   c                   ó”   • \ rS rSrSrSrSS.S jrS r\S 5       r	SS
 jr
SS jrS rSS jr\S 5       r\S 5       r\S 5       rSrg	)rA   i\  a%  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)

r#   F©r4   c                ó^   • U(       d  SUS'   [        U0 UD6n[        R                  " U /UQ76 $ )Nr#   r"   ©r   r   rC   ©rD   r4   rE   rF   s       r-   rC   ÚPoint2D.__new__‘  ó3   € ÞØˆF�5‰MÜ˜$Ð) &Ñ)ˆDÜ×%Ò% cÐ1¨DÒ1Ð1rQ   c                 ó
   • X:H  $ r1   r‡   r^   s     r-   r`   ÚPoint2D.__contains__—  ó
   € Ø‰|ÐrQ   c                 ó^   • U R                   U R                  U R                   U R                  4$ )zgReturn a tuple (xmin, ymin, xmax, ymax) representing the bounding
rectangle for the geometric figure.

)re   Úyrs   s    r-   ÚboundsÚPoint2D.boundsš  s#   € ð —‘˜Ÿ™ §¡¨¯©Ð/Ð/rQ   Nc                 ó¶   • [        U5      n[        U5      nU nUb  [        USS9nXR-  nUR                  u  pg[        X6-  XG-  -
  XF-  X7-  -   5      nUb  XR-  nU$ )zû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)

r#   rª   )r   r   r   rE   )rM   ÚangleÚptÚcrW   rÙ   re   r  s           r-   ÚrotateÚPoint2D.rotate£  sk   € ô& �‹JˆÜ�‹JˆàˆØ‰>Ü�r˜qÑ!ˆBØ‰HˆBØ�w‰w‰ˆÜ�1‘3˜™‘9˜a™c A¡C™iÓ(ˆØ‰>Ø‰HˆBØˆ	rQ   c                 óð   • U(       aJ  [        USS9nU R                  " U* R                  6 R                  X5      R                  " UR                  6 $ [        U R                  U-  U R
                  U-  5      $ )a}  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)

r#   rª   )r   Ú	translaterE   Úscalere   r  )rM   re   r  r  s       r-   r!  ÚPoint2D.scaleÃ  s_   € ö, Ü�r˜qÑ!ˆBØ—>’> R C§:¡:Ð.×4Ñ4°QÓ:×DÒDÀbÇgÁgÐNÐNÜ�T—V‘V˜A‘X˜tŸv™v a™xÓ(Ð(rQ   c           	      óÎ   • UR                   (       a  UR                  S:X  d  [        S5      eU R                  u  p#[	        [        SSX#S/5      U-  R                  5       S   SS 6 $ )zÝ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
)r5   r5   zmatrix must be a 3x3 matrixr   r5   r   Nr#   )Ú	is_MatrixÚshaper;   rE   r   r   Útolist)rM   Úmatrixre   r  s       r-   Ú	transformÚPoint2D.transformÞ  sa   € ð × ×  V§\¡\°VÓ%;ÜÐ:Ó;Ð;Ø�y‰y‰ˆÜ”v˜a  Q¨1 IÓ.¨vÑ5×=Ñ=Ó?ÀÑBÀ2ÀAÐFÐGÐGrQ   c                 óN   • [        U R                  U-   U R                  U-   5      $ )a4  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)

)r   re   r  )rM   re   r  s      r-   r   ÚPoint2D.translateí  s!   € ô* �T—V‘V˜a‘Z §¡¨!¡Ó,Ð,rQ   c                 ó   • U R                   $ )zŒ
Returns the two coordinates of the Point.

Examples
========

>>> from sympy import Point2D
>>> p = Point2D(0, 1)
>>> p.coordinates
(0, 1)
r]   rs   s    r-   ÚcoordinatesÚPoint2D.coordinates  ó   € ð �y‰yÐrQ   c                 ó    • U R                   S   $ )zz
Returns the X coordinate of the Point.

Examples
========

>>> from sympy import Point2D
>>> p = Point2D(0, 1)
>>> p.x
0
r   r]   rs   s    r-   re   Ú	Point2D.x  ó   € ð �y‰y˜‰|ÐrQ   c                 ó    • U R                   S   $ )zz
Returns the Y coordinate of the Point.

Examples
========

>>> from sympy import Point2D
>>> p = Point2D(0, 1)
>>> p.y
1
r   r]   rs   s    r-   r  Ú	Point2D.y"  r2  rQ   r‡   r1   )r   r   N)r   r   )r  r  r  r  r  r‹   rC   r`   r	  r  r  r!  r(  r   r-  re   r  r
  r‡   rQ   r-   rA   rA   \  sƒ   † ñ0ðd Ðà%*õ 2òð ñ0ó ð0ôô@)ò6Hô-ð. ñó ðð ñó ðð ñó órQ   rA   c                   ó¬   • \ rS rSrSrSrSS.S jrS r\S 5       r	S	 r
S
 rS rSS jrS rSS jr\S 5       r\S 5       r\S 5       r\S 5       rSrg)rB   i1  a¾  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)

r5   Fr  c                ó^   • U(       d  SUS'   [        U0 UD6n[        R                  " U /UQ76 $ )Nr5   r"   r  r  s       r-   rC   ÚPoint3D.__new__a  r  rQ   c                 ó
   • X:H  $ r1   r‡   r^   s     r-   r`   ÚPoint3D.__contains__g  r  rQ   c                  ó(   • [         R                  " U 6 $ )aK  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
)r   rÉ   )r–   s    r-   Úare_collinearÚPoint3D.are_collinearj  s   € ôD ×!Ò! 6Ð*Ð*rQ   c                 óú   • U R                  U5      n[        [        S U 5       6 5      nUR                  U R                  -
  U-  UR                  U R                  -
  U-  UR
                  U R
                  -
  U-  /$ )a   
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]
c              3   ó*   #   • U  H	  oS -  v •  M     g7fr¬   r‡   r�   s     r-   r.   Ú+Point3D.direction_cosine.<locals>.<genexpr>¥  s   é € Ð'¢Q ˜!–t¢Qùs   ‚)Údirection_ratior   r   re   r  Úz)rM   Úpointr,   rY   s       r-   Údirection_cosineÚPoint3D.direction_cosineŽ  sq   € ð, × Ñ  Ó'ˆÜ”Ñ'¡QÓ'Ð(Ó)ˆØ—‘˜4Ÿ6™6Ñ! QÑ&¨¯©°$·&±&Ñ(8¸AÑ'=Ø—‘˜4Ÿ6™6Ñ! QÑ&ð(ð 	(rQ   c                 ó–   • UR                   U R                   -
  UR                  U R                  -
  UR                  U R                  -
  /$ )zæ
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]
)re   r  rA  )rM   rB  s     r-   r@  ÚPoint3D.direction_ratio©  s8   € ð, —‘˜4Ÿ6™6Ñ! E§G¡G¨d¯f©fÑ$4°u·w±wÀÇÁÑ7GÐIÐIrQ   c                 ó    • [        U[        5      (       d
  [        USS9n[        U[        5      (       a
  X:X  a  U /$ / $ UR	                  U 5      $ )aø  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)]

r5   rª   )r2   r   r   rB   rÄ   rj   s     r-   rÄ   ÚPoint3D.intersectionÁ  sL   € ô< ˜%¤×0Ñ0Ü˜% QÑ'ˆEÜ�eœW×%Ñ%Ø‹}Ø�v�ØˆIØ×!Ñ! $Ó'Ð'rQ   Nc                 ó  • U(       aL  [        U5      nU R                  " U* R                  6 R                  XU5      R                  " UR                  6 $ [        U R                  U-  U R
                  U-  U R                  U-  5      $ )a~  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)

)rB   r   rE   r!  re   r  rA  )rM   re   r  rA  r  s        r-   r!  ÚPoint3D.scaleç  sh   € ö, Ü˜“ˆBØ—>’> R C§:¡:Ð.×4Ñ4°Q¸1Ó=×GÒGÈÏÉÐQÐQÜ�t—v‘v˜a‘x §¡¨¡¨4¯6©6°!©8Ó4Ð4rQ   c           
      óè   • UR                   (       a  UR                  S:X  d  [        S5      eU R                  u  p#n[	        U5      n[        [        SSX#US/5      U-  R                  5       S   SS 6 $ )z¹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
)é   rL  zmatrix must be a 4x4 matrixr   rL  r   Nr5   )r$  r%  r;   rE   r   rB   r   r&  )rM   r'  re   r  rA  r¡   s         r-   r(  ÚPoint3D.transform  so   € ð × ×  V§\¡\°VÓ%;ÜÐ:Ó;Ð;Ø—)‘)‰ˆˆaÜ�fÓˆÜœ  1 q¨Q° lÓ3°AÑ5×=Ñ=Ó?ÀÑBÀ2ÀAÐFÐGÐGrQ   c                 ój   • [        U R                  U-   U R                  U-   U R                  U-   5      $ )a  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)

)rB   re   r  rA  )rM   re   r  rA  s       r-   r   ÚPoint3D.translate  s+   € ô* �t—v‘v ‘z 4§6¡6¨A¡:¨t¯v©v¸©zÓ:Ð:rQ   c                 ó   • U R                   $ )z”
Returns the three coordinates of the Point.

Examples
========

>>> from sympy import Point3D
>>> p = Point3D(0, 1, 2)
>>> p.coordinates
(0, 1, 2)
r]   rs   s    r-   r-  ÚPoint3D.coordinates(  r/  rQ   c                 ó    • U R                   S   $ )z}
Returns the X coordinate of the Point.

Examples
========

>>> from sympy import Point3D
>>> p = Point3D(0, 1, 3)
>>> p.x
0
r   r]   rs   s    r-   re   Ú	Point3D.x7  r2  rQ   c                 ó    • U R                   S   $ )z}
Returns the Y coordinate of the Point.

Examples
========

>>> from sympy import Point3D
>>> p = Point3D(0, 1, 2)
>>> p.y
1
r   r]   rs   s    r-   r  Ú	Point3D.yF  r2  rQ   c                 ó    • U R                   S   $ )z}
Returns the Z coordinate of the Point.

Examples
========

>>> from sympy import Point3D
>>> p = Point3D(0, 1, 1)
>>> p.z
1
r#   r]   rs   s    r-   rA  Ú	Point3D.zU  r2  rQ   r‡   )r   r   r   N)r   r   r   )r  r  r  r  r  r‹   rC   r`   r  r;  rC  r@  rÄ   r!  r(  r   r	  r-  re   r  rA  r
  r‡   rQ   r-   rB   rB   1  s£   † ñ+ðZ Ðà%*õ 2òð ñ!+ó ð!+òF(ò6Jò0$(ôL5ò6Hô;ð. ñó ðð ñó ðð ñó ðð ñó órQ   rB   ),r  r<   Ú
sympy.corer   r   r   Úsympy.core.addr   Úsympy.core.containersr   Úsympy.core.numbersr   Úsympy.core.parametersr	   Úsympy.simplify.simplifyr
   r   Úsympy.geometry.exceptionsr   Ú(sympy.functions.elementary.miscellaneousr   Ú$sympy.functions.elementary.complexesr   Ú(sympy.functions.elementary.trigonometricr   r   Úsympy.matricesr   Úsympy.matrices.expressionsr   Úsympy.utilities.iterablesr   r   Úsympy.utilities.miscr   r   r   Úentityr   Úmpmath.libmp.libmpfr   r   rA   rB   r‡   rQ   r-   Ú<module>rh     sq   ðñó& ç 'Ñ 'Ý Ý 'Ý $Ý 3ß 7Ý 3Ý 9Ý 3ß =Ý !Ý 0ß 7ß CÑ Cå "å +ôo ˆNô o ôdSˆeô Sôjqˆeõ qrQ   