1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 __docformat__ = 'reStructuredText'
20
21 import operator
22 import math
23
24 from pytilities.types import NumberType
25 from pytilities.delegation import delegated, delegator_factory
26 from pytilities.overloading import overloaded, Overload, Param
31
32
33
34 assert not isinstance(x, basestring)
35 assert not isinstance(y, basestring)
36 self.x = x
37 self.y = y
38
39
40
41
42
43
44
45
46 @delegator_factory()
47 -class Vector(object):
48
49 """
50 2D Point/Vector
51
52 Class fields:
53
54 - `INFINITY`: immutable Vector of positive infinity
55 - `NULL`: immutable Vector (0, 0)
56
57 Instance methods:
58
59 - `move_to`: Set x, y position
60 - `move_by`: Move vector by x, y
61 - `assign`: Assign values of other vector to this one
62 - `copy`: Shallow copy
63 - `normalize`: Normalize vector
64 - `normalized`: Get a normalized copy of this vector
65 - `dot`: Dot product
66 - `cross`:
67 - `reflect`:
68
69 Instance properties:
70
71 - `x`: Read-write, x position
72 - `y`: Read-write, y position
73 - `length`: Read-write, length of vector
74 - `length_squared`: Read-only, length squared
75
76 Operators:
77
78 str(s)
79 s == v
80 s != v
81 s + v
82 s += v
83 s - v
84 s -= v
85 s * n
86 s *= n
87 s / n
88 s /= n
89 -s
90 self explanatory
91
92 len(s)
93 returns 2
94
95 iter(s)
96 iterates over its x and y value
97
98 abs(s)
99 returns length of vector
100 """
101
102 @staticmethod
104 profiles['default'] |= profiles['immutable']
105
108
110 self.__storage = storage
111
112 @overloaded((
113 Overload(__init_xy,
114 Param("x", NumberType, default=0),
115 Param("y", NumberType, default=0)),
116 Overload(__init_storage,
117 Param("storage"))))
119 """
120 Constructs a 2D Vector
121
122 Overloaded, parameters:
123
124 :a:
125 x :: float | int = 0
126 y :: float | int = 0
127
128 :b:
129 storage :: object(x, y)
130 an object that provides storage for the x and y values
131 """
132 pass
133
134 @delegated()
135 @delegated("immutable", modifiers="r")
136 @property
138 """Read-write, x position ::float | int"""
139 return self.__storage.x
140
141 @x.setter
142 - def x(self, value):
143 self.__storage.x = value
144
145 @delegated()
146 @delegated("immutable", modifiers="r")
147 @property
149 """Read-write, y position ::float | int"""
150 return self.__storage.y
151
152 @y.setter
153 - def y(self, value):
154 self.__storage.y = value
155
156 @delegated()
158 """
159 Set x, y coords
160
161 Parameters:
162
163 `x` :: float | int
164 x position
165
166 `y` :: float | int
167 y position
168 """
169 self.x, self.y = x, y
170
171 @delegated()
173 """
174 Move vector by (x, y)
175
176 Parameters:
177
178 `x` :: float | int
179 x position
180
181 `y` :: float | int
182 y position
183 """
184 self.x += x
185 self.y += y
186
187 @delegated()
189 """
190 Assigns the values of another vector to this vector
191
192 v :: Vector -- the other vector
193 """
194 self.x = v.x
195 self.y = v.y
196
197 @delegated("immutable")
199 return "<%s (%s,%s)>" % (self.__class__.__name__,
200 self.x, self.y)
201
202 @delegated("immutable")
205
206 @delegated("immutable")
208 """Returns shallow copy :: Vector"""
209 return self.__copy__()
210
211 @delegated("immutable")
213 """other :: Vector"""
214 return self.x == other.x and \
215 self.y == other.y
216
217 @delegated("immutable")
219 """other :: Vector"""
220 return not self.__eq__(other)
221
222 @delegated("immutable")
225
226 @delegated("immutable")
228 return (self.x, self.y)[key]
229
230 @delegated()
232 (self.x, self.y)[key] = value
233
234 @delegated("immutable")
236 """Iterates over its x and y value"""
237 return iter((self.x, self.y))
238
239 @delegated("immutable")
241 try:
242 return tuple([(self.x, self.y)['xy'.index(c)] \
243 for c in name])
244 except ValueError:
245 raise AttributeError, name
246
247 @delegated("immutable")
249 """other :: Vector"""
250 v = self.copy()
251 v += other
252 return v
253
254 @delegated()
256 """other :: Vector"""
257 self.x += other.x
258 self.y += other.y
259 return self
260
261 @delegated("immutable")
263 return self + (-other)
264
265 @delegated("immutable")
267 """other :: number"""
268 v = self.copy()
269 v *= other
270 return v
271
272 @delegated("immutable")
274 """other :: number"""
275 return self * other
276
277 @delegated()
279 """other :: number"""
280 self.x *= other
281 self.y *= other
282 return self
283
284 @delegated("immutable")
286 """other :: number"""
287 return Vector(operator.div(self.x, other),
288 operator.div(self.y, other))
289
290 @delegated("immutable")
292 """other :: number"""
293 return Vector(operator.div(other, self.x),
294 operator.div(other, self.y))
295
296 @delegated("immutable")
298 """other :: number"""
299 return Vector(operator.floordiv(self.x, other),
300 operator.floordiv(self.y, other))
301
302 @delegated("immutable")
304 """other :: number"""
305 return Vector(operator.floordiv(other, self.x),
306 operator.floordiv(other, self.y))
307
308 @delegated("immutable")
310 """other :: number"""
311 return Vector(operator.truediv(self.x, other),
312 operator.truediv(self.y, other))
313
314
315 @delegated("immutable")
317 """other :: number"""
318 return Vector(operator.truediv(other, self.x),
319 operator.truediv(other, self.y))
320
321 @delegated("immutable")
324
325 @delegated("immutable")
328
329 @delegated("immutable")
331 return math.sqrt(self.x ** 2 + \
332 self.y ** 2)
333
334 @delegated()
335 @property
337 """
338 Read-write, length of vector
339
340 Returns :: float | int
341
342 Set parameters:
343
344 value :: number
345 new length
346 """
347 return abs(self)
348
349 @length.setter
351 d = self.length * value
352 self *= value
353
354 @delegated("immutable")
355 @property
357 """Read-only, length squared :: float | int"""
358 return self.x ** 2 + \
359 self.y ** 2
360
361 @delegated()
363 """
364 Normalize vector
365
366 Returns :: Vector
367 """
368 d = self.length
369
370 if d:
371 self /= d
372
373 return self
374
375 @delegated("immutable")
377 """
378 Get a normalized copy of this vector
379
380 Returns :: Vector
381 """
382 v = self.copy()
383 return v.normalize()
384
385 @delegated("immutable")
386 - def dot(self, other):
387 """
388 Get the dot product of this vector with `other`
389
390 Parameters:
391
392 `other` :: Vector
393 the other vector
394
395 Returns :: float | int
396 """
397 return self.x * other.x + \
398 self.y * other.y
399
400 @delegated("immutable")
404
405 @delegated("immutable")
407
408
409 d = 2 * (self.x * normal.x + self.y * normal.y)
410 return Vector(self.x - d * normal.x,
411 self.y - d * normal.y)
412
413
414
415 from .immutablevector import ImmutableVector
416
417 Vector.INFINITY = ImmutableVector(Vector(float("inf"), float("inf")))
418 Vector.NULL = ImmutableVector(Vector(0, 0))
419