Clase Punto Con Python 3

por | 18 enero, 2014

Hola
Siguiendo con mi auto-aprendizaje de Python 3 me he puesto a crear una clase Point (punto) con sus pertinentes métodos y funciones. Por internet hay información sobre el tema, pero muy caótica e incompleta. La mayoría se dedican a declarar una clase Point para puntos en 2 dimensiones y un par de métodos y ahí acaban. En mi caso he intentado hacerla lo más completa posible para poder utilizarla en otros códigos, vamos que me he dedicado a crearla como un módulo propio, pero casero. En cuanto a módulos y paquetes estoy pendiente de poder profundizar algo más en el tema, pero lo que he realizado hasta aquí es totalmente funcional y útil; quizá vaya añadiendo más funciones con el tiempo, poco a poco.
Seguramente te estés preguntando en qué consiste todo esto, o no . He partido de la idea básica de poder realizar las operaciones elementales sobre puntos en 2 y tres dimensiones: suma, resta, producto por escalar, etc.. Es decir, supongamos que tenemos 2 puntos P y Q que queremos sumarlos componente a componente, pues sería P(a,b,c) + Q(d,e,f) = (a+d,b+e,c+f); y así con el resto de operaciones básicas.
Todas estas operaciones básicas las he implementado dentro de una clase llamada Point. Las operaciones las he implementado mediante la sobrecarga de operadores en Python. También he sobrecargado la salida por consola de la representación de un punto cualquiera, lo he hecho sobrecargando el método __repr__. Todos los operadores sobrecargados al pertenecer a la clase Point son métodos de la clase.
¿Por qué sobrecargar los operadores? Muy sencillo, porque cuando queramos utilizar nuestros propios códigos podremos realizar operaciones escribiendo cosas como: P+Q-R+2*T, por ejemplo.
En la clase Point he creado un incializador (no un constructor) para inicializar las coordenadas de un punto, con el código:

  1. __slots__ = ('x', 'y', 'z')
  2.  
  3.     def __init__(self, x=0, y=0, z=None):
  4.         """The init method, we initialize third coordinates of a point. The
  5.         third coordinate is None because we need the same class for 2D and 3D.
  6.         You can initialize a point for example: P = Point() or P = Point(a,b)
  7.         or P = Point(a,b,c)"""
  8.         self.x = x
  9.         self.y = y
  10.         self.z = z

En el mismo he inicializado z como None, de esa forma no tengo que implementar una clase para puntos bidimensionales y otra para los tridimensionales, así la misma clase me sirve para ambas dimensiones. Esto lo pude resolver preguntando en la web-foro STACKOVERFLOW, te la recomiendo mucho para preguntar y resolver dudas.
Si te fijas en el código anterior he añadido un slot, ¿para qué?, según tengo entendido es para que los inicializadores que tenemos en __init__ sean reservados de forma conveniente en memoria, así nuestro código sólo reserva memoria para x,y,z, estrictamente.
El código entero de la clase Point lo he metido dentro de un directorio llamado Point con el nombre de fichero Point.py, el código es:

  1. #/usr/bin/env python3
  2. # -*- coding: utf-8 -*-
  3.  
  4.  
  5. class Point(object):
  6.     """"Class to calculate the usual operations with points in bi and tridimen-
  7.     sional coordinates"""
  8.     __slots__ = ('x', 'y', 'z')
  9.  
  10.     def __init__(self, x=0, y=0, z=None):
  11.         """The init method, we initialize third coordinates of a point. The
  12.         third coordinate is None because we need the same class for 2D and 3D.
  13.         You can initialize a point for example: P = Point() or P = Point(a,b)
  14.         or P = Point(a,b,c)"""
  15.         self.x = x
  16.         self.y = y
  17.         self.z = z
  18.  
  19.     def __add__(self, P):
  20.         """The operator sum overloaded. You can add points writing P + Q, where
  21.         P and Q are two points."""
  22.         S = Point()
  23.         S.x = self.x + P.x
  24.         S.y = self.y + P.y
  25.         if self.z is not None:
  26.             if P.z is None:
  27.                 raise ValueError('Cannot add a 2D point to a 3D point')
  28.             S.z = self.z + P.z
  29.         return S
  30.  
  31.     __radd__ = __add__
  32.  
  33.     def __sub__(self, P):
  34.         """The operator subtraction overloaded. You can subtract points writing
  35.         P - Q, where P and Q are two points."""
  36.         R = Point()
  37.         R.x = self.x - P.x
  38.         R.y = self.y - P.y
  39.         if self.z is not None:
  40.             if P.z is None:
  41.                 raise ValueError('Cannot add a 2D point to a 3D point')
  42.             R.z = self.z + P.z
  43.         return R
  44.  
  45.     __rsub__ = __sub__
  46.  
  47.     def __mul__(self, num):
  48.         """The operator mult overloaded. You can multipy a scalar with a point,
  49.         writing a * P, where a is a scalar and P is a point."""
  50.         M = Point()
  51.         M.x = num * self.x
  52.         M.y = num * self.y
  53.         if self.z is not None:
  54.             M.z = num * self.z
  55.         return M
  56.  
  57.     __rmul__ = __mul__
  58.  
  59.     def __pow__(self, n):
  60.         """The operator pow overloaded. You can powering points writing P ** n,
  61.          where P is a point, and n is the power. If P = (a, b), then P ** n
  62.          calculates (a ** n, b ** n)"""
  63.         P = Point()
  64.         if n == -1 and (self.x == 0 or self.y == 0):
  65.             raise ValueError('Error. Divided by zero.')
  66.         P.x = self.x ** n
  67.         P.y = self.y ** n
  68.         if self.z is not None:
  69.             P.z = self.z ** n
  70.         return P
  71.  
  72.     def __neg__(self):
  73.         """The operator negative overloaded. If P is a point, you can
  74.         calculate -P, the P point changed it sign in each coordinates."""
  75.         O = Point()
  76.         O.x = - self.x
  77.         O.y = - self.y
  78.         if self.z is not None:
  79.             O.z = -self.z
  80.         return O
  81.  
  82.     def __invert__(self):
  83.         """The operator invert overloaded. You can calculate P ** (-1) from a
  84.         P point. If P = (a,b), P ** (-1) = (a ** (-1), b ** (-1)). You must
  85.         write the instruction as ~P."""
  86.         I = Point()
  87.         if self.x == 0 or self.y == 0 or self.z == 0:
  88.             raise ValueError('Error. Divided by zero.')
  89.         else:
  90.             I.x = 1. / self.x
  91.             I.y = 1 / self.y
  92.             if self.z is not None:
  93.                 I.z = 1. / self.z
  94.             return I
  95.  
  96.     def __repr__(self):
  97.         """An overloaded method that it writes a point in a terminal."""
  98.         if self.z is not None:
  99.             return('({}, {}, {})'.format(self.x, self.y, self.z))
  100.         else:
  101.             return('({}, {})'.format(self.x, self.y))

Todo el código esta comentado en inglés, respetando los standards de Python 3, de esa forma desde la terminal de Python podemos acceder a su documentación introduciendo el comando help(Point).
En un fichero a parte, y en el mismo directorio he añadido determinadas funciones que a mi parecer son útiles para trabajar con puntos: distancia entre dos puntos, punto medio entre dos puntos, traslación de puntos, el incentro y transformar de rectangulares a polares (y viceversa), de rectangulares a cilíndricas (y viceversa), de rectangulares a esféricas (y viceversa), y de cilíndricas a esféricas (y viceversa); contemplando los casos en radianes y en grados sexagesimales. Las conversiones de coordenadas las he implementado en miras a usos futuros de ellas para dibujar puntos en Python usando herramientas como Matplotlib, Ipython o Sagemath. Todas estas funciones las he metido en un fichero llamado funcpoints.py con el siguiente código:

  1. #/usr/bin/env python3
  2. # -*- coding: utf-8 -*-
  3.  
  4.  
  5. from math import sqrt, pow, hypot, atan2, cos, sin, degrees, radians
  6. from Point import Point
  7. import sys
  8.  
  9.  
  10. def dist(P, Q):
  11.     """A math Point function to calculate the distance between 2 points."""
  12.     if P.z is not None and Q.z is not None:
  13.         d = sqrt(pow(P.x - Q.x, 2) + pow(P.y - Q.y, 2) +
  14.         pow(P.z - Q.z, 2))
  15.         return d
  16.     else:
  17.         d = sqrt(pow(P.x - Q.x, 2) + pow(P.y - Q.y, 2))
  18.         return d
  19.  
  20.  
  21. def mid_point(P, Q):
  22.     """A math Point function to calculate the mid point between 2 points."""
  23.     R = (1. / 2.) * (P + Q)
  24.     return R
  25.  
  26.  
  27. def translate2D(P, tx, ty):
  28.     """A math Point function to calculate a  tx, ty translation of a point
  29.     If you put translate((1,2), -2, 3), the function calculate a point with -2
  30.     x-coordinate and +3 y-coordinate, i.e., the point is (-1,5). The function
  31.     calculates for a 2D Point."""
  32.     R = Point()
  33.     R.x = P.x + tx
  34.     R.y = P.y + ty
  35.     if P.z is not None:
  36.         raise ValueError('Cannot add a 2D point to a 3D point')
  37.     return R
  38.  
  39.  
  40. def translate3D(P, tx, ty, tz):
  41.     """A math Point function to calculate a  tx, ty, tz translation of a point
  42.     If you put translate((1,2), -2, 3, 4), the function calculate a point with
  43.     -2 x-coordinate, +3 y-coordinate and +4 z-coordinate, i.e., the point is
  44.     (-1,5). The function calculates for a 3D Point."""
  45.     R = Point()
  46.     R.x = P.x + tx
  47.     R.y = P.y + ty
  48.     R.z = P.z + tz
  49.     return R
  50.  
  51.  
  52. def incenter(A, B, C):
  53.     """A math Point function to calculate the Incenter Point in a triangle."""
  54.     I = Point()
  55.     a = dist(B, C)
  56.     b = dist(A, C)
  57.     c = dist(A,
  58.     sumd = a + b + c
  59.     I = (a / sumd) * A + (b / sumd) * B + (c / sumd) * C
  60.     return I
  61.  
  62.  
  63. def rect2pol(P):
  64.     """A math point function to calculate the polar coordinates of a point in
  65.     rectangular points."""
  66.     R = Point()
  67.     R.x = hypot(P.x, P.y)
  68.     R.y = atan2(P.y, P.x)
  69.     if P.z is not None:
  70.         raise ValueError('Cannot add a 2D point to a 3D point')
  71.     return(R)
  72.  
  73.  
  74. def rect2poldeg(P):
  75.     """A math point function to calculate the polar coordinates of a point in
  76.     rectangular points. In sexagesimal degrees."""
  77.     R = Point()
  78.     R.x = hypot(P.x, P.y)
  79.     R.y = degrees(atan2(P.y, P.x))
  80.     if P.z is not None:
  81.         raise ValueError('Cannot add a 2D point to a 3D point')
  82.     return(R)
  83.  
  84.  
  85. def pol2rect(P):
  86.     """A math point function to calculate the rectangular coordinates of a
  87.     point in polar coordinates."""
  88.     R = Point()
  89.     if P.x <= 0:
  90.         raise ValueError('The radius must be > 0')
  91.     R.x = P.x * cos(P.y)
  92.     R.y = P.x * sin(P.y)
  93.     if P.z is not None:
  94.         raise ValueError('Cannot add a 2D point to a 3D point')
  95.     return(R)
  96.  
  97.  
  98. def pol2rectdeg(P):
  99.     """A math point function to calculate the rectangular coordinates of a
  100.     point in polar coordinates. In sexagesimal degrees."""
  101.     R = Point()
  102.     if P.x <= 0:
  103.         raise ValueError('The radius must be > 0')
  104.     R.x = P.x * cos(radians(P.y))
  105.     R.y = P.x * sin(radians(P.y))
  106.     if P.z is not None:
  107.         raise ValueError('Cannot add a 2D point to a 3D point')
  108.     return(R)
  109.  
  110.  
  111. def rect2cyl(P):
  112.     """A math point function to calculate the cilindrical coordinates of a
  113.     point in rectangular coordinates."""
  114.     R = Point()
  115.     R.x = hypot(P.x, P.y)
  116.     R.y = atan2(P.y, P.x)
  117.     R.z = P.z
  118.     if P.z is None:
  119.         raise ValueError('Cannot add a 3D point to a 2D point')
  120.     return(R)
  121.  
  122.  
  123. def rect2cyldeg(P):
  124.     """A math point function to calculate the cilindrical coordinates of a
  125.     point in rectangular coordinates. In sexagesimal degrees."""
  126.     R = Point()
  127.     R.x = hypot(P.x, P.y)
  128.     R.y = degrees(atan2(P.y, P.x))
  129.     R.z = P.z
  130.     if P.z is None:
  131.         raise ValueError('Cannot add a 3D point to a 2D point')
  132.     return(R)
  133.  
  134.  
  135. def cyl2rect(P):
  136.     """A math point function to calculate the rectangular coordinates of a
  137.     point in cilindrical coordinates."""
  138.     R = Point()
  139.     if P.x <= 0:
  140.         raise ValueError('The radius must be > 0')
  141.     R.x = P.x * cos(P.y)
  142.     R.y = P.x * sin(P.y)
  143.     R.z = P.z
  144.     if P.z is None:
  145.         raise ValueError('Cannot add a 3D point to a 2D point')
  146.     return(R)
  147.  
  148.  
  149. def cyl2rectdeg(P):
  150.     """A math point function to calculate the rectangular coordinates of a
  151.     point in cilindrical coordinates. In sexagesimal degrees."""
  152.     R = Point()
  153.     if P.x <= 0:
  154.         raise ValueError('The radius must be > 0')
  155.     R.x = P.x * cos(radians(P.y))
  156.     R.y = P.x * sin(radians(P.y))
  157.     R.z = P.z
  158.     if P.z is None:
  159.         raise ValueError('Cannot add a 3D point to a 2D point')
  160.     return(R)
  161.  
  162.  
  163. def rect2sph(P):
  164.     """A math point function to calculate the rectangular coordinates of a
  165.     point in spherical coordinates."""
  166.     R = Point()
  167.     R.x = sqrt(pow(P.x, 2.) + pow(P.y, 2.) + pow(P.z, 2.))
  168.     R.y = atan2(sqrt(pow(P.x, 2.) + pow(P.y, 2.)), P.z)
  169.     R.z = atan2(P.y, P.x)
  170.     if P.z is None:
  171.         raise ValueError('Cannot add a 3D point to a 2D point')
  172.     return(R)
  173.  
  174.  
  175. def rect2sphdeg(P):
  176.     """A math point function to calculate the rectangular coordinates of a
  177.     point in spherical coordinates. In sexagesimal degrees."""
  178.     R = Point()
  179.     R.x = sqrt(pow(P.x, 2.) + pow(P.y, 2.) + pow(P.z, 2.))
  180.     R.y = degrees(atan2(sqrt(pow(P.x, 2.) + pow(P.y, 2.)), P.z))
  181.     R.z = degrees(atan2(P.y, P.x))
  182.     if P.z is None:
  183.         raise ValueError('Cannot add a 3D point to a 2D point')
  184.     return(R)
  185.  
  186.  
  187. def sph2rect(P):
  188.     """A math point function to calculate the spherical coordinates of a
  189.     point in rectangular coordinates."""
  190.     R = Point()
  191.     if P.x <= 0:
  192.         raise ValueError('The radius must be > 0')
  193.     R.x = P.x * sin(P.y) * cos(P.z)
  194.     R.y = P.x * sin(P.y) * sin(P.z)
  195.     R.z = P.x * cos(P.y)
  196.     if P.z is None:
  197.         raise ValueError('Cannot add a 3D point to a 2D point')
  198.     return(R)
  199.  
  200.  
  201. def sph2rectdeg(P):
  202.     """A math point function to calculate the spherical coordinates of a
  203.     point in rectangular coordinates. In sexagesimal degrees."""
  204.     R = Point()
  205.     if P.x <= 0:
  206.         raise ValueError('The radius must be > 0')
  207.     R.x = P.x * sin(radians(P.y)) * cos(radians(P.z))
  208.     R.y = P.x * sin(radians(P.y)) * sin(radians(P.z))
  209.     R.z = P.x * cos(radians(P.y))
  210.     if P.z is None:
  211.         raise ValueError('Cannot add a 3D point to a 2D point')
  212.     return(R)
  213.  
  214.  
  215. def cyl2sph(P):
  216.     """A math point function to calculate the cilindrical coordinates of a
  217.     point in spherical coordinates."""
  218.     R = Point()
  219.     if P.x <= 0:
  220.         raise ValueError('The radius must be > 0')
  221.     R.x = sqrt(pow(P.x, 2.) + pow(P.z, 2.))
  222.     R.y = atan2(P.x, P.z)
  223.     R.z = P.y
  224.     if P.z is None:
  225.         raise ValueError('Cannot add a 3D point to a 2D point')
  226.     return(R)
  227.  
  228.  
  229. def sph2cyl(P):
  230.     """A math point function to calculate the spherical coordinates of a
  231.     point in cilindrical coordinates."""
  232.     R = Point()
  233.     if P.x <= 0:
  234.         raise ValueError('The radius must be > 0')
  235.     R.x = P.x * sin(P.y)
  236.     R.y = P.z
  237.     R.z = P.x * cos(P.y)
  238.     if P.z is None:
  239.         raise ValueError('Cannot add a 3D point to a 2D point')
  240.     return(R)
  241.  
  242.  
  243. def input_point(P):
  244.         """A method when the user of a terminal can input a point with 2 or 3
  245.         coordinates. The user must write (1,2,3) or (1,2), for instance."""
  246.         print(('Enter a point (x,y) or (x,y,z):'))
  247.         point = sys.stdin.readline()
  248.         point = point.replace('(', '')
  249.         point = point.replace(')', '')
  250.         l1 = point.rsplit(',')
  251.         P.x = float(l1[0])
  252.         P.y = float(l1[1])
  253.         if len(l1) == 3:
  254.             P.z = float(l1[2])
  255.         l1 = []

He decidido implementarlas como funciones y no como métodos de la clase porque me resulta más legible escribir dist(P, Q) que P.dist(Q), manías matemáticas
También he implementado una función para entrada de datos por consola llamada input_point, en ella lo más nuevo que he utilizado en mis conocimientos de Python3 es no utilizar raw_input o input para la petición de datos por terminal, me he decidido por utilizar la función sys.stdin.readline() importando el módulo sys de Python. Es la que me ha respetado todos los standards de Python3.
Para que funcione todo como módulos hay que crear dentro del mismo directorio un fichero llamado __init__.py, normalmente con dejarlo vacío es suficiente. En mi caso, y como utilizo el IDE Ninja-IDE he usado una opción que tiene para que te lo rellene convenientemente, el código es:

  1. from Point import Point
  2. from funcpoints import dist
  3. from funcpoints import mid_point
  4. from funcpoints import translate2D
  5. from funcpoints import translate3D
  6. from funcpoints import incenter
  7. from funcpoints import rect2pol
  8. from funcpoints import rect2poldeg
  9. from funcpoints import pol2rect
  10. from funcpoints import pol2rectdeg
  11. from funcpoints import rect2cyl
  12. from funcpoints import rect2cyldeg
  13. from funcpoints import cyl2rect
  14. from funcpoints import cyl2rectdeg
  15. from funcpoints import rect2sph
  16. from funcpoints import rect2sphdeg
  17. from funcpoints import sph2rect
  18. from funcpoints import sph2rectdeg
  19. from funcpoints import cyl2sph
  20. from funcpoints import sph2cyl
  21. from funcpoints import input_point

Para los que vengan de C++, el __init__.py, si lo rellenas viene a ser los archivos cabecera .h.
Finalmente, para ver que todo funciona bien me he creado un fichero Pruebas.py fuera del directorio con el siguiente código:

  1. #/usr/bin/env python3
  2. # -*- coding: utf-8 -*-
  3.  
  4. from Point import *
  5. from math import sqrt
  6.  
  7.  
  8. def main():
  9.     'We create 2 points P(0,0), Q(0,0)'
  10.     P = Point()
  11.     Q = Point()
  12.  
  13.     input_point(P)
  14.     input_point(Q)
  15.  
  16.     S = P + Q
  17.     R = P - Q
  18.     M = 5 * P
  19.     N = R + S + M + 2 * P
  20.     P1 = Point(4,
  21.     Q1 = Point(3, 4, 5)
  22.     Q1T = translate3D(Q1, 5, -2, 5)
  23.  
  24.     print(('P + Q = {}'.format(S)))
  25.     print(('P - Q = {}'.format(R)))
  26.     print(('5 * P= {}'.format(M)))
  27.     print(('N = R + S + M + 2 * P = {}'.format(N)))
  28.     print(('P ** 3 = {}'.format(P ** 3)))
  29.     print(('-P = {}'.format(- P)))
  30.     print(('P ** (-1) = {}'.format(~ P)))
  31.     print(('Distance(P, Q) = {}'.format(dist(P, Q))))
  32.     print(('Middle Point(P, Q) = {}'.format(mid_point(P, Q))))
  33.     print(('Translation 2D point {} 5 OX and -2 OY ={}'
  34.     .format(P1, translate2D(P1, 5, -2))))
  35.     print(('Translation 3D point {} 5OX, -2OY and 5OZ= {}'.format(Q1, Q1T)))
  36.  
  37.     A = Point(0, 0)
  38.     B = Point(1, 0)
  39.     C = Point(1. / 2., sqrt(3.) / 2.)
  40.     I = incenter(A, B, C)
  41.     print(('Incenter Point = {}'.format(I)))
  42.  
  43.     D = Point(2, -3)
  44.     pol = rect2pol(D)
  45.     pol1 = rect2poldeg(D)
  46.     rect = pol2rect(pol)
  47.     E = Point(4, 120)
  48.     rect1 = pol2rectdeg(E)
  49.  
  50.     A1 = Point(3, 4, 5)
  51.     A11 = rect2cyl(A1)
  52.     A111 = rect2cyldeg(A1)
  53.     A12 = cyl2rect(A11)
  54.     A122 = Point(2., 60., 5.)
  55.     cil = cyl2rectdeg(A122)
  56.  
  57.     A21 = rect2sph(A1)
  58.     A211 = rect2sphdeg(A1)
  59.     A22 = sph2rect(A21)
  60.     A222 = Point(2, 120, 225)
  61.     sph = sph2rectdeg(A222)
  62.  
  63.     A3 = cyl2sph(A11)
  64.     A31 = sph2rect(A3)
  65.  
  66.     A4 = sph2cyl(A3)
  67.     A41 = cyl2rect(A4)
  68.  
  69.     print(('From Rectangulars to Polars = {}'.format(pol)))
  70.     print(('From Rectangulars to Polars (Degrees) = {}'.format(pol1)))
  71.     print(('From Polars to Rectangulars = {}'.format(rect)))
  72.     print(('From Polars to Rectangulars (Degrees) {} = {}'.format(E, rect1)))
  73.     print(('From Rectangulars to Cylindricals = {}'.format(A11)))
  74.     print(('From Rectangulars to Cylindricals (Degrees) = {}'.format(A111)))
  75.     print(('From Cylindricals to Rectangulars = {}'.format(A12)))
  76.     print(('From Cylindricals to Rectangulars (Degrees)\
  77.     {} = {}'.format(A122, cil)))
  78.     print(('From Rectangulars to Sphericals = {}'.format(A21)))
  79.     print(('From Rectangulars to Sphericals (Degrees) = {}'.format(A211)))
  80.     print(('From Sphericals to Rectangulars = {}'.format(A22)))
  81.     print(('From Sphericals to Rectangulars (Degrees)\
  82.     {} = {}'.format(A222, sph)))
  83.     print(('From Cylindricals to Sphericals {} = {}'.format(A11, A3)))
  84.     print(('From Sphericals to Rectangulars {} = {}'.format(A3, A31)))
  85.     print(('From Sphericals to Cylindricals {} = {}'.format(A3, A4)))
  86.     print(('From Cylindricals to Rectangulars {} = {}'.format(A4, A41)))
  87.  
  88. if __name__ == '__main__':
  89.     main()

Una de las posibles salidas por terminal del código puede ser la siguiente:


Running: /home/tobal/ProgramasPython3/Punto/pruebasPunto.py (Sat Jan 18 11:17:05 2014)

Enter a point (x,y) or (x,y,z):
(1,2,3)
Enter a point (x,y) or (x,y,z):
(4,5,6)
P + Q = (5.0, 7.0, 9.0)
P – Q = (-3.0, -3.0, 9.0)
5 * P= (5.0, 10.0, 15.0)
N = R + S + M + 2 * P = (9.0, 18.0, 39.0)
P ** 3 = (1.0, 8.0, 27.0)
-P = (-1.0, -2.0, -3.0)
P ** (-1) = (1.0, 0.5, 0.333333333333)
Distance(P, Q) = 5.19615242271
Middle Point(P, Q) = (2.5, 3.5, 4.5)
Translation 2D point (4, 5 OX and -2 OY =(9, 6)
Translation 3D point (3, 4, 5) 5OX, -2OY and 5OZ= (8, 2, 10)
Incenter Point = (0.5, 0.288675134595)
From Rectangulars to Polars = (3.60555127546, -0.982793723247)
From Rectangulars to Polars (Degrees) = (3.60555127546, -56.309932474)
From Polars to Rectangulars = (2.0, -3.0)
From Polars to Rectangulars (Degrees) (4, 120) = (-2.0, 3.46410161514)
From Rectangulars to Cylindricals = (5.0, 0.927295218002, 5)
From Rectangulars to Cylindricals (Degrees) = (5.0, 53.1301023542, 5)
From Cylindricals to Rectangulars = (3.0, 4.0, 5)
From Cylindricals to Rectangulars (Degrees) (2.0, 60.0, 5.0) = (1.0, 1.73205080757, 5.0)
From Rectangulars to Sphericals = (7.07106781187, 0.785398163397, 0.927295218002)
From Rectangulars to Sphericals (Degrees) = (7.07106781187, 45.0, 53.1301023542)
From Sphericals to Rectangulars = (3.0, 4.0, 5.0)
From Sphericals to Rectangulars (Degrees) (2, 120, 225) = (-1.22474487139, -1.22474487139, -1.0)
From Cylindricals to Sphericals (5.0, 0.927295218002, 5) = (7.07106781187, 0.785398163397, 0.927295218002)
From Sphericals to Rectangulars (7.07106781187, 0.785398163397, 0.927295218002) = (3.0, 4.0, 5.0)
From Sphericals to Cylindricals (7.07106781187, 0.785398163397, 0.927295218002) = (5.0, 0.927295218002, 5.0)
From Cylindricals to Rectangulars (5.0, 0.927295218002, 5.0) = (3.0, 4.0, 5.0)

Ejecucción Exitosa!


Lo siento, lo he realizado en inglés porque así practico
¿Cosas a mejorar o añadir en el código? Pues poder hacer que x,y,z pasen a ser miembros privados, lo he probado pero no me ha funcado. También añadir funciones para calcular: baricentro, ortocentro, recta de Euler y alguna más que no recuerde ahora.
También sería una buena idea implementar una clase derivada para clases de equivalencia, conjuntos cociente, R.B.E y relaciones de orden (supremos, ínfimos, maximales, minimales, etc..)
Si sabes mejorar el código eres libre de ponerlo en los comentarios de este artículo
Todos los conceptos matemáticos aquí vistos puedes consultarlos en la Wikipedia, no muerde !!!

Saludos

Un pensamiento en “Clase Punto Con Python 3

  1. Pingback: Bitacoras.com

Los comentarios están cerrados.