Fix license headers

[linpy.git] / pypol / geometry.py

diff --git a/pypol/geometry.py b/pypol/geometry.py
index 520a1ec..9a5fa8f 100644 (file)
--- a/pypol/geometry.py
+++ b/pypol/geometry.py
@@ -1,3 +1,20 @@
+# Copyright 2014 MINES ParisTech
+#
+# This file is part of Linpy.
+#
+# Linpy is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Linpy is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Linpy.  If not, see <http://www.gnu.org/licenses/>.
+

 import math
 import numbers
 import operator
 import math
 import numbers
 import operator


@@ -107,27 +124,27 @@ class Point(Coordinates, GeometricObject):
     """
 
     def isorigin(self):
     """
 
     def isorigin(self):

-    """
-    Return True if a Point is the origin.
-    """
+        """
+        Return True if a Point is the origin.
+        """

         return not bool(self)
 
     def __hash__(self):
         return super().__hash__()
 
     def __add__(self, other):
         return not bool(self)
 
     def __hash__(self):
         return super().__hash__()
 
     def __add__(self, other):

-    """
-    Adds a Point to a Vector and returns the result as a Point.
-    """
+        """
+        Adds a Point to a Vector and returns the result as a Point.
+        """

         if not isinstance(other, Vector):
             return NotImplemented
         coordinates = self._map2(other, operator.add)
         return Point(coordinates)
 
     def __sub__(self, other):
         if not isinstance(other, Vector):
             return NotImplemented
         coordinates = self._map2(other, operator.add)
         return Point(coordinates)
 
     def __sub__(self, other):

-    """
-    Returns the difference between two Points as a Vector.
-    """
+        """
+        Returns the difference between two Points as a Vector.
+        """

         coordinates = []
         if isinstance(other, Point):
             coordinates = self._map2(other, operator.sub)
         coordinates = []
         if isinstance(other, Point):
             coordinates = self._map2(other, operator.sub)


@@ -139,16 +156,16 @@ class Point(Coordinates, GeometricObject):
             return NotImplemented
 
     def __eq__(self, other):
             return NotImplemented
 
     def __eq__(self, other):

-    """
-    Compares two Points for equality.
-    """
+        """
+        Compares two Points for equality.
+        """

         return isinstance(other, Point) and \
             self._coordinates == other._coordinates
 
     def aspolyhedron(self):
         return isinstance(other, Point) and \
             self._coordinates == other._coordinates
 
     def aspolyhedron(self):

-    """
-    Return a Point as a polyhedron.
-    """
+        """
+        Return a Point as a polyhedron.
+        """

         from .polyhedra import Polyhedron
         equalities = []
         for symbol, coordinate in self.coordinates():
         from .polyhedra import Polyhedron
         equalities = []
         for symbol, coordinate in self.coordinates():


@@ -173,18 +190,18 @@ class Vector(Coordinates):
         return super().__new__(cls, coordinates)
 
     def isnull(self):
         return super().__new__(cls, coordinates)
 
     def isnull(self):

-    """
-    Returns true if a Vector is null.
-    """
+        """
+        Returns true if a Vector is null.
+        """

         return not bool(self)
 
     def __hash__(self):
         return super().__hash__()
 
     def __add__(self, other):
         return not bool(self)
 
     def __hash__(self):
         return super().__hash__()
 
     def __add__(self, other):

-    """
-    Adds either a Point or Vector to a Vector.
-    """
+        """
+        Adds either a Point or Vector to a Vector.
+        """

         if isinstance(other, (Point, Vector)):
             coordinates = self._map2(other, operator.add)
             return other.__class__(coordinates)
         if isinstance(other, (Point, Vector)):
             coordinates = self._map2(other, operator.add)
             return other.__class__(coordinates)


@@ -192,7 +209,9 @@ class Vector(Coordinates):
 
     def angle(self, other):
         """
 
     def angle(self, other):
         """

-        Retrieve the angle required to rotate the vector into the vector passed in argument. The result is an angle in radians, ranging between -pi and pi.
+        Retrieve the angle required to rotate the vector into the vector passed
+        in argument. The result is an angle in radians, ranging between -pi and
+        pi.

         """
         if not isinstance(other, Vector):
             raise TypeError('argument must be a Vector instance')
         """
         if not isinstance(other, Vector):
             raise TypeError('argument must be a Vector instance')


@@ -238,9 +257,9 @@ class Vector(Coordinates):
         return result
 
     def __eq__(self, other):
         return result
 
     def __eq__(self, other):

-    """
-    Compares two Vectors for equality.
-    """
+        """
+        Compares two Vectors for equality.
+        """

         return isinstance(other, Vector) and \
             self._coordinates == other._coordinates
 
         return isinstance(other, Vector) and \
             self._coordinates == other._coordinates
 


@@ -248,9 +267,9 @@ class Vector(Coordinates):
         return hash(tuple(self.coordinates()))
 
     def __mul__(self, other):
         return hash(tuple(self.coordinates()))
 
     def __mul__(self, other):

-    """
-    Multiplies a Vector by a scalar value.
-    """
+        """
+        Multiplies a Vector by a scalar value.
+        """

         if not isinstance(other, numbers.Real):
             return NotImplemented
         coordinates = self._map(lambda coordinate: other * coordinate)
         if not isinstance(other, numbers.Real):
             return NotImplemented
         coordinates = self._map(lambda coordinate: other * coordinate)


@@ -259,16 +278,16 @@ class Vector(Coordinates):
     __rmul__ = __mul__
 
     def __neg__(self):
     __rmul__ = __mul__
 
     def __neg__(self):

-    """
-    Returns the negated form of a Vector.
-    """
+        """
+        Returns the negated form of a Vector.
+        """

         coordinates = self._map(operator.neg)
         return Vector(coordinates)
 
     def norm(self):
         coordinates = self._map(operator.neg)
         return Vector(coordinates)
 
     def norm(self):

-    """
-    Normalizes a Vector. 
-    """
+        """
+        Normalizes a Vector.
+        """

         return math.sqrt(self.norm2())
 
     def norm2(self):
         return math.sqrt(self.norm2())
 
     def norm2(self):


@@ -281,9 +300,9 @@ class Vector(Coordinates):
         return self / self.norm()
 
     def __sub__(self, other):
         return self / self.norm()
 
     def __sub__(self, other):

-    """
-    Subtract a Point or Vector from a Vector. 
-    """
+        """
+        Subtract a Point or Vector from a Vector.
+        """

         if isinstance(other, (Point, Vector)):
             coordinates = self._map2(other, operator.sub)
             return other.__class__(coordinates)
         if isinstance(other, (Point, Vector)):
             coordinates = self._map2(other, operator.sub)
             return other.__class__(coordinates)