pypol/coordinates.py

   1 import math
   2 import numbers
   3 import operator
   4
   5 from abc import ABC, abstractmethod
   6 from collections import OrderedDict, Mapping
   7
   8 from .linexprs import Symbol
   9
  10
  11 __all__ = [
  12     'Point',
  13     'Vector',
  14 ]
  15
  16
  17 class Coordinates(ABC):
  18
  19     __slots__ = (
  20         '_coordinates',
  21     )
  22
  23     @abstractmethod
  24     def __new__(cls):
  25         super().__new__(cls)
  26
  27     @property
  28     def symbols(self):
  29         return tuple(self._coordinates)
  30
  31     @property
  32     def dimension(self):
  33         return len(self.symbols)
  34
  35     def coordinates(self):
  36         yield from self._coordinates.items()
  37
  38     def coordinate(self, symbol):
  39         if not isinstance(symbol, Symbol):
  40             raise TypeError('symbol must be a Symbol instance')
  41         return self._coordinates[symbol]
  42
  43     __getitem__ = coordinate
  44
  45     def __bool__(self):
  46         return any(self._coordinates.values())
  47
  48     def __hash__(self):
  49         return hash(tuple(self.coordinates()))
  50
  51     def __repr__(self):
  52         string = ', '.join(['{!r}: {!r}'.format(symbol, coordinate)
  53             for symbol, coordinate in self.coordinates()])
  54         return '{}({{{}}})'.format(self.__class__.__name__, string)
  55
  56     def _map(self, func):
  57         for symbol, coordinate in self.coordinates():
  58             yield symbol, func(coordinate)
  59
  60     def _iter2(self, other):
  61         if self.symbols != other.symbols:
  62             raise ValueError('arguments must belong to the same space')
  63         coordinates1 = self._coordinates.values()
  64         coordinates2 = other._coordinates.values()
  65         yield from zip(self.symbols, coordinates1, coordinates2)
  66
  67     def _map2(self, other, func):
  68         for symbol, coordinate1, coordinate2 in self._iter2(other):
  69             yield symbol, func(coordinate1, coordinate2)
  70
  71
  72 class Point(Coordinates):
  73     """
  74     This class represents points in space.
  75     """
  76
  77     def __new__(cls, coordinates=None):
  78         if isinstance(coordinates, Mapping):
  79             coordinates = coordinates.items()
  80         self = object().__new__(cls)
  81         self._coordinates = OrderedDict()
  82         for symbol, coordinate in sorted(coordinates,
  83                 key=lambda item: item[0].sortkey()):
  84             if not isinstance(symbol, Symbol):
  85                 raise TypeError('symbols must be Symbol instances')
  86             if not isinstance(coordinate, numbers.Real):
  87                 raise TypeError('coordinates must be real numbers')
  88             self._coordinates[symbol] = coordinate
  89         return self
  90
  91     def isorigin(self):
  92         return not bool(self)
  93
  94     def __add__(self, other):
  95         if not isinstance(other, Vector):
  96             return NotImplemented
  97         coordinates = self._map2(other, operator.add)
  98         return Point(coordinates)
  99
 100     def __sub__(self, other):
 101         coordinates = []
 102         if isinstance(other, Point):
 103             coordinates = self._map2(other, operator.sub)
 104             return Vector(coordinates)
 105         elif isinstance(other, Vector):
 106             coordinates = self._map2(other, operator.sub)
 107             return Point(coordinates)
 108         else:
 109             return NotImplemented
 110
 111     def __eq__(self, other):
 112         return isinstance(other, Point) and \
 113             self._coordinates == other._coordinates
 114
 115     def aspolyhedron(self):
 116         from .polyhedra import Polyhedron
 117         equalities = []
 118         for symbol, coordinate in self.coordinates():
 119             equalities.append(symbol - coordinate)
 120         return Polyhedron(equalities)
 121
 122
 123 class Vector(Coordinates):
 124     """
 125     This class represents displacements in space.
 126     """
 127
 128     __slots__ = (
 129         '_coordinates',
 130     )
 131
 132     def __new__(cls, initial, terminal=None):
 133         self = object().__new__(cls)
 134         if not isinstance(initial, Point):
 135             initial = Point(initial)
 136         if terminal is None:
 137             self._coordinates = initial._coordinates
 138         elif not isinstance(terminal, Point):
 139             terminal = Point(terminal)
 140             self._coordinates = terminal._map2(initial, operator.sub)
 141         return self
 142
 143     def isnull(self):
 144         return not bool(self)
 145
 146     def __add__(self, other):
 147         if isinstance(other, (Point, Vector)):
 148             coordinates = self._map2(other, operator.add)
 149             return other.__class__(coordinates)
 150         return NotImplemented
 151
 152     def angle(self, other):
 153         """
 154         Retrieve the angle required to rotate the vector into the vector passed
 155         in argument. The result is an angle in radians, ranging between -pi and
 156         pi.
 157         """
 158         if not isinstance(other, Vector):
 159             raise TypeError('argument must be a Vector instance')
 160         cosinus = self.dot(other) / (self.norm()*other.norm())
 161         return math.acos(cosinus)
 162
 163     def cross(self, other):
 164         """
 165         Calculate the cross product of two Vector3D structures.
 166         """
 167         if not isinstance(other, Vector):
 168             raise TypeError('other must be a Vector instance')
 169         if self.dimension != 3 or other.dimension != 3:
 170             raise ValueError('arguments must be three-dimensional vectors')
 171         if self.symbols != other.symbols:
 172             raise ValueError('arguments must belong to the same space')
 173         x, y, z = self.symbols
 174         coordinates = []
 175         coordinates.append((x, self[y]*other[z] - self[z]*other[y]))
 176         coordinates.append((y, self[z]*other[x] - self[x]*other[z]))
 177         coordinates.append((z, self[x]*other[y] - self[y]*other[x]))
 178         return Vector(coordinates)
 179
 180     def __truediv__(self, other):
 181         """
 182         Divide the vector by the specified scalar and returns the result as a
 183         vector.
 184         """
 185         if not isinstance(other, numbers.Real):
 186             return NotImplemented
 187         coordinates = self._map(lambda coordinate: coordinate / other)
 188         return Vector(coordinates)
 189
 190     def dot(self, other):
 191         """
 192         Calculate the dot product of two vectors.
 193         """
 194         if not isinstance(other, Vector):
 195             raise TypeError('argument must be a Vector instance')
 196         result = 0
 197         for symbol, coordinate1, coordinate2 in self._iter2(other):
 198             result += coordinate1 * coordinate2
 199         return result
 200
 201     def __eq__(self, other):
 202         return isinstance(other, Vector) and \
 203             self._coordinates == other._coordinates
 204
 205     def __hash__(self):
 206         return hash(tuple(self.coordinates()))
 207
 208     def __mul__(self, other):
 209         if not isinstance(other, numbers.Real):
 210             return NotImplemented
 211         coordinates = self._map(lambda coordinate: other * coordinate)
 212         return Vector(coordinates)
 213
 214     __rmul__ = __mul__
 215
 216     def __neg__(self):
 217         coordinates = self._map(operator.neg)
 218         return Vector(coordinates)
 219
 220     def norm(self):
 221         return math.sqrt(self.norm2())
 222
 223     def norm2(self):
 224         result = 0
 225         for coordinate in self._coordinates.values():
 226             result += coordinate ** 2
 227         return result
 228
 229     def asunit(self):
 230         return self / self.norm()
 231
 232     def __sub__(self, other):
 233         if isinstance(other, (Point, Vector)):
 234             coordinates = self._map2(other, operator.sub)
 235             return other.__class__(coordinates)
 236         return NotImplemented