|
from numbers import Number |
|
import math |
|
import operator |
|
import warnings |
|
|
|
|
|
__all__ = ["Vector"] |
|
|
|
|
|
class Vector(tuple): |
|
|
|
"""A math-like vector. |
|
|
|
Represents an n-dimensional numeric vector. ``Vector`` objects support |
|
vector addition and subtraction, scalar multiplication and division, |
|
negation, rounding, and comparison tests. |
|
""" |
|
|
|
__slots__ = () |
|
|
|
def __new__(cls, values, keep=False): |
|
if keep is not False: |
|
warnings.warn( |
|
"the 'keep' argument has been deprecated", |
|
DeprecationWarning, |
|
) |
|
if type(values) == Vector: |
|
|
|
return values |
|
return super().__new__(cls, values) |
|
|
|
def __repr__(self): |
|
return f"{self.__class__.__name__}({super().__repr__()})" |
|
|
|
def _vectorOp(self, other, op): |
|
if isinstance(other, Vector): |
|
assert len(self) == len(other) |
|
return self.__class__(op(a, b) for a, b in zip(self, other)) |
|
if isinstance(other, Number): |
|
return self.__class__(op(v, other) for v in self) |
|
raise NotImplementedError() |
|
|
|
def _scalarOp(self, other, op): |
|
if isinstance(other, Number): |
|
return self.__class__(op(v, other) for v in self) |
|
raise NotImplementedError() |
|
|
|
def _unaryOp(self, op): |
|
return self.__class__(op(v) for v in self) |
|
|
|
def __add__(self, other): |
|
return self._vectorOp(other, operator.add) |
|
|
|
__radd__ = __add__ |
|
|
|
def __sub__(self, other): |
|
return self._vectorOp(other, operator.sub) |
|
|
|
def __rsub__(self, other): |
|
return self._vectorOp(other, _operator_rsub) |
|
|
|
def __mul__(self, other): |
|
return self._scalarOp(other, operator.mul) |
|
|
|
__rmul__ = __mul__ |
|
|
|
def __truediv__(self, other): |
|
return self._scalarOp(other, operator.truediv) |
|
|
|
def __rtruediv__(self, other): |
|
return self._scalarOp(other, _operator_rtruediv) |
|
|
|
def __pos__(self): |
|
return self._unaryOp(operator.pos) |
|
|
|
def __neg__(self): |
|
return self._unaryOp(operator.neg) |
|
|
|
def __round__(self, *, round=round): |
|
return self._unaryOp(round) |
|
|
|
def __eq__(self, other): |
|
if isinstance(other, list): |
|
|
|
other = tuple(other) |
|
return super().__eq__(other) |
|
|
|
def __ne__(self, other): |
|
return not self.__eq__(other) |
|
|
|
def __bool__(self): |
|
return any(self) |
|
|
|
__nonzero__ = __bool__ |
|
|
|
def __abs__(self): |
|
return math.sqrt(sum(x * x for x in self)) |
|
|
|
def length(self): |
|
"""Return the length of the vector. Equivalent to abs(vector).""" |
|
return abs(self) |
|
|
|
def normalized(self): |
|
"""Return the normalized vector of the vector.""" |
|
return self / abs(self) |
|
|
|
def dot(self, other): |
|
"""Performs vector dot product, returning the sum of |
|
``a[0] * b[0], a[1] * b[1], ...``""" |
|
assert len(self) == len(other) |
|
return sum(a * b for a, b in zip(self, other)) |
|
|
|
|
|
|
|
def toInt(self): |
|
warnings.warn( |
|
"the 'toInt' method has been deprecated, use round(vector) instead", |
|
DeprecationWarning, |
|
) |
|
return self.__round__() |
|
|
|
@property |
|
def values(self): |
|
warnings.warn( |
|
"the 'values' attribute has been deprecated, use " |
|
"the vector object itself instead", |
|
DeprecationWarning, |
|
) |
|
return list(self) |
|
|
|
@values.setter |
|
def values(self, values): |
|
raise AttributeError( |
|
"can't set attribute, the 'values' attribute has been deprecated", |
|
) |
|
|
|
def isclose(self, other: "Vector", **kwargs) -> bool: |
|
"""Return True if the vector is close to another Vector.""" |
|
assert len(self) == len(other) |
|
return all(math.isclose(a, b, **kwargs) for a, b in zip(self, other)) |
|
|
|
|
|
def _operator_rsub(a, b): |
|
return operator.sub(b, a) |
|
|
|
|
|
def _operator_rtruediv(a, b): |
|
return operator.truediv(b, a) |
|
|
