Fix license headers
[linpy.git] / pypol / geometry.py
1 # Copyright 2014 MINES ParisTech
2 #
3 # This file is part of Linpy.
4 #
5 # Linpy is free software: you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation, either version 3 of the License, or
8 # (at your option) any later version.
9 #
10 # Linpy is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
14 #
15 # You should have received a copy of the GNU General Public License
16 # along with Linpy. If not, see <http://www.gnu.org/licenses/>.
17
18 import math
19 import numbers
20 import operator
21
22 from abc import ABC, abstractproperty, abstractmethod
23 from collections import OrderedDict, Mapping
24
25 from .linexprs import Symbol
26
27
28 __all__ = [
29 'GeometricObject',
30 'Point',
31 'Vector',
32 ]
33
34
35 class GeometricObject(ABC):
36
37 @abstractproperty
38 def symbols(self):
39 pass
40
41 @property
42 def dimension(self):
43 return len(self.symbols)
44
45 @abstractmethod
46 def aspolyhedron(self):
47 pass
48
49 def asdomain(self):
50 return self.aspolyhedron()
51
52
53 class Coordinates:
54
55 __slots__ = (
56 '_coordinates',
57 )
58
59 def __new__(cls, coordinates):
60 if isinstance(coordinates, Mapping):
61 coordinates = coordinates.items()
62 self = object().__new__(cls)
63 self._coordinates = OrderedDict()
64 for symbol, coordinate in sorted(coordinates,
65 key=lambda item: item[0].sortkey()):
66 if not isinstance(symbol, Symbol):
67 raise TypeError('symbols must be Symbol instances')
68 if not isinstance(coordinate, numbers.Real):
69 raise TypeError('coordinates must be real numbers')
70 self._coordinates[symbol] = coordinate
71 return self
72
73 @property
74 def symbols(self):
75 return tuple(self._coordinates)
76
77 @property
78 def dimension(self):
79 return len(self.symbols)
80
81 def coordinates(self):
82 yield from self._coordinates.items()
83
84 def coordinate(self, symbol):
85 if not isinstance(symbol, Symbol):
86 raise TypeError('symbol must be a Symbol instance')
87 return self._coordinates[symbol]
88
89 __getitem__ = coordinate
90
91 def values(self):
92 yield from self._coordinates.values()
93
94 def __bool__(self):
95 return any(self._coordinates.values())
96
97 def __hash__(self):
98 return hash(tuple(self.coordinates()))
99
100 def __repr__(self):
101 string = ', '.join(['{!r}: {!r}'.format(symbol, coordinate)
102 for symbol, coordinate in self.coordinates()])
103 return '{}({{{}}})'.format(self.__class__.__name__, string)
104
105 def _map(self, func):
106 for symbol, coordinate in self.coordinates():
107 yield symbol, func(coordinate)
108
109 def _iter2(self, other):
110 if self.symbols != other.symbols:
111 raise ValueError('arguments must belong to the same space')
112 coordinates1 = self._coordinates.values()
113 coordinates2 = other._coordinates.values()
114 yield from zip(self.symbols, coordinates1, coordinates2)
115
116 def _map2(self, other, func):
117 for symbol, coordinate1, coordinate2 in self._iter2(other):
118 yield symbol, func(coordinate1, coordinate2)
119
120
121 class Point(Coordinates, GeometricObject):
122 """
123 This class represents points in space.
124 """
125
126 def isorigin(self):
127 """
128 Return True if a Point is the origin.
129 """
130 return not bool(self)
131
132 def __hash__(self):
133 return super().__hash__()
134
135 def __add__(self, other):
136 """
137 Adds a Point to a Vector and returns the result as a Point.
138 """
139 if not isinstance(other, Vector):
140 return NotImplemented
141 coordinates = self._map2(other, operator.add)
142 return Point(coordinates)
143
144 def __sub__(self, other):
145 """
146 Returns the difference between two Points as a Vector.
147 """
148 coordinates = []
149 if isinstance(other, Point):
150 coordinates = self._map2(other, operator.sub)
151 return Vector(coordinates)
152 elif isinstance(other, Vector):
153 coordinates = self._map2(other, operator.sub)
154 return Point(coordinates)
155 else:
156 return NotImplemented
157
158 def __eq__(self, other):
159 """
160 Compares two Points for equality.
161 """
162 return isinstance(other, Point) and \
163 self._coordinates == other._coordinates
164
165 def aspolyhedron(self):
166 """
167 Return a Point as a polyhedron.
168 """
169 from .polyhedra import Polyhedron
170 equalities = []
171 for symbol, coordinate in self.coordinates():
172 equalities.append(symbol - coordinate)
173 return Polyhedron(equalities)
174
175
176 class Vector(Coordinates):
177 """
178 This class represents displacements in space.
179 """
180
181 def __new__(cls, initial, terminal=None):
182 if not isinstance(initial, Point):
183 initial = Point(initial)
184 if terminal is None:
185 coordinates = initial._coordinates
186 else:
187 if not isinstance(terminal, Point):
188 terminal = Point(terminal)
189 coordinates = terminal._map2(initial, operator.sub)
190 return super().__new__(cls, coordinates)
191
192 def isnull(self):
193 """
194 Returns true if a Vector is null.
195 """
196 return not bool(self)
197
198 def __hash__(self):
199 return super().__hash__()
200
201 def __add__(self, other):
202 """
203 Adds either a Point or Vector to a Vector.
204 """
205 if isinstance(other, (Point, Vector)):
206 coordinates = self._map2(other, operator.add)
207 return other.__class__(coordinates)
208 return NotImplemented
209
210 def angle(self, other):
211 """
212 Retrieve the angle required to rotate the vector into the vector passed
213 in argument. The result is an angle in radians, ranging between -pi and
214 pi.
215 """
216 if not isinstance(other, Vector):
217 raise TypeError('argument must be a Vector instance')
218 cosinus = self.dot(other) / (self.norm()*other.norm())
219 return math.acos(cosinus)
220
221 def cross(self, other):
222 """
223 Calculate the cross product of two Vector3D structures.
224 """
225 if not isinstance(other, Vector):
226 raise TypeError('other must be a Vector instance')
227 if self.dimension != 3 or other.dimension != 3:
228 raise ValueError('arguments must be three-dimensional vectors')
229 if self.symbols != other.symbols:
230 raise ValueError('arguments must belong to the same space')
231 x, y, z = self.symbols
232 coordinates = []
233 coordinates.append((x, self[y]*other[z] - self[z]*other[y]))
234 coordinates.append((y, self[z]*other[x] - self[x]*other[z]))
235 coordinates.append((z, self[x]*other[y] - self[y]*other[x]))
236 return Vector(coordinates)
237
238 def __truediv__(self, other):
239 """
240 Divide the vector by the specified scalar and returns the result as a
241 vector.
242 """
243 if not isinstance(other, numbers.Real):
244 return NotImplemented
245 coordinates = self._map(lambda coordinate: coordinate / other)
246 return Vector(coordinates)
247
248 def dot(self, other):
249 """
250 Calculate the dot product of two vectors.
251 """
252 if not isinstance(other, Vector):
253 raise TypeError('argument must be a Vector instance')
254 result = 0
255 for symbol, coordinate1, coordinate2 in self._iter2(other):
256 result += coordinate1 * coordinate2
257 return result
258
259 def __eq__(self, other):
260 """
261 Compares two Vectors for equality.
262 """
263 return isinstance(other, Vector) and \
264 self._coordinates == other._coordinates
265
266 def __hash__(self):
267 return hash(tuple(self.coordinates()))
268
269 def __mul__(self, other):
270 """
271 Multiplies a Vector by a scalar value.
272 """
273 if not isinstance(other, numbers.Real):
274 return NotImplemented
275 coordinates = self._map(lambda coordinate: other * coordinate)
276 return Vector(coordinates)
277
278 __rmul__ = __mul__
279
280 def __neg__(self):
281 """
282 Returns the negated form of a Vector.
283 """
284 coordinates = self._map(operator.neg)
285 return Vector(coordinates)
286
287 def norm(self):
288 """
289 Normalizes a Vector.
290 """
291 return math.sqrt(self.norm2())
292
293 def norm2(self):
294 result = 0
295 for coordinate in self._coordinates.values():
296 result += coordinate ** 2
297 return result
298
299 def asunit(self):
300 return self / self.norm()
301
302 def __sub__(self, other):
303 """
304 Subtract a Point or Vector from a Vector.
305 """
306 if isinstance(other, (Point, Vector)):
307 coordinates = self._map2(other, operator.sub)
308 return other.__class__(coordinates)
309 return NotImplemented