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
 116 class Vector(Coordinates):
 117     """
 118     This class represents displacements in space.
 119     """
 120
 121     __slots__ = (
 122         '_coordinates',
 123     )
 124
 125     def __new__(cls, initial, terminal=None):
 126         self = object().__new__(cls)
 127         if not isinstance(initial, Point):
 128             initial = Point(initial)
 129         if terminal is None:
 130             self._coordinates = initial._coordinates
 131         elif not isinstance(terminal, Point):
 132             terminal = Point(terminal)
 133             self._coordinates = terminal._map2(initial, operator.sub)
 134         return self
 135
 136     def isnull(self):
 137         return not bool(self)
 138
 139     def __add__(self, other):
 140         if isinstance(other, (Point, Vector)):
 141             coordinates = self._map2(other, operator.add)
 142             return other.__class__(coordinates)
 143         return NotImplemented
 144
 145     def angle(self, other):
 146         """
 147         Retrieve the angle required to rotate the vector into the vector passed
 148         in argument. The result is an angle in radians, ranging between -pi and
 149         pi.
 150         """
 151         if not isinstance(other, Vector):
 152             raise TypeError('argument must be a Vector instance')
 153         cosinus = self.dot(other) / (self.norm()*other.norm())
 154         return math.acos(cosinus)
 155
 156     def cross(self, other):
 157         """
 158         Calculate the cross product of two Vector3D structures.
 159         """
 160         if not isinstance(other, Vector):
 161             raise TypeError('other must be a Vector instance')
 162         if self.dimension != 3 or other.dimension != 3:
 163             raise ValueError('arguments must be three-dimensional vectors')
 164         if self.symbols != other.symbols:
 165             raise ValueError('arguments must belong to the same space')
 166         x, y, z = self.symbols
 167         coordinates = []
 168         coordinates.append((x, self[y]*other[z] - self[z]*other[y]))
 169         coordinates.append((y, self[z]*other[x] - self[x]*other[z]))
 170         coordinates.append((z, self[x]*other[y] - self[y]*other[x]))
 171         return Vector(coordinates)
 172
 173     def __truediv__(self, other):
 174         """
 175         Divide the vector by the specified scalar and returns the result as a
 176         vector.
 177         """
 178         if not isinstance(other, numbers.Real):
 179             return NotImplemented
 180         coordinates = self._map(lambda coordinate: coordinate / other)
 181         return Vector(coordinates)
 182
 183     def dot(self, other):
 184         """
 185         Calculate the dot product of two vectors.
 186         """
 187         if not isinstance(other, Vector):
 188             raise TypeError('argument must be a Vector instance')
 189         result = 0
 190         for symbol, coordinate1, coordinate2 in self._iter2(other):
 191             result += coordinate1 * coordinate2
 192         return result
 193
 194     def __eq__(self, other):
 195         return isinstance(other, Vector) and \
 196             self._coordinates == other._coordinates
 197
 198     def __hash__(self):
 199         return hash(tuple(self.coordinates()))
 200
 201     def __mul__(self, other):
 202         if not isinstance(other, numbers.Real):
 203             return NotImplemented
 204         coordinates = self._map(lambda coordinate: other * coordinate)
 205         return Vector(coordinates)
 206
 207     __rmul__ = __mul__
 208
 209     def __neg__(self):
 210         coordinates = self._map(operator.neg)
 211         return Vector(coordinates)
 212
 213     def norm(self):
 214         return math.sqrt(self.norm2())
 215
 216     def norm2(self):
 217         result = 0
 218         for coordinate in self._coordinates.values():
 219             result += coordinate ** 2
 220         return result
 221
 222     def asunit(self):
 223         return self / self.norm()
 224
 225     def __sub__(self, other):
 226         if isinstance(other, (Point, Vector)):
 227             coordinates = self._map2(other, operator.sub)
 228             return other.__class__(coordinates)
 229         return NotImplemented