vector_v5.py

# BEGIN VECTOR_V5
"""
A multi-dimensional ``Vector`` class, take 5

A ``Vector`` is built from an iterable of numbers::

    >>> Vector([3.1, 4.2])
    Vector([3.1, 4.2])
    >>> Vector((3, 4, 5))
    Vector([3.0, 4.0, 5.0])
    >>> Vector(range(10))
    Vector([0.0, 1.0, 2.0, 3.0, 4.0, ...])


Tests with 2-dimensions (same results as ``vector2d_v1.py``)::

    >>> v1 = Vector([3, 4])
    >>> x, y = v1
    >>> x, y
    (3.0, 4.0)
    >>> v1
    Vector([3.0, 4.0])
    >>> v1_clone = eval(repr(v1))
    >>> v1 == v1_clone
    True
    >>> print(v1)
    (3.0, 4.0)
    >>> octets = bytes(v1)
    >>> octets
    b'd\\x00\\x00\\x00\\x00\\x00\\x00\\x08@\\x00\\x00\\x00\\x00\\x00\\x00\\x10@'
    >>> abs(v1)
    5.0
    >>> bool(v1), bool(Vector([0, 0]))
    (True, False)


Test of ``.frombytes()`` class method:

    >>> v1_clone = Vector.frombytes(bytes(v1))
    >>> v1_clone
    Vector([3.0, 4.0])
    >>> v1 == v1_clone
    True


Tests with 3-dimensions::

    >>> v1 = Vector([3, 4, 5])
    >>> x, y, z = v1
    >>> x, y, z
    (3.0, 4.0, 5.0)
    >>> v1
    Vector([3.0, 4.0, 5.0])
    >>> v1_clone = eval(repr(v1))
    >>> v1 == v1_clone
    True
    >>> print(v1)
    (3.0, 4.0, 5.0)
    >>> abs(v1)  # doctest:+ELLIPSIS
    7.071067811...
    >>> bool(v1), bool(Vector([0, 0, 0]))
    (True, False)


Tests with many dimensions::

    >>> v7 = Vector(range(7))
    >>> v7
    Vector([0.0, 1.0, 2.0, 3.0, 4.0, ...])
    >>> abs(v7)  # doctest:+ELLIPSIS
    9.53939201...


Test of ``.__bytes__`` and ``.frombytes()`` methods::

    >>> v1 = Vector([3, 4, 5])
    >>> v1_clone = Vector.frombytes(bytes(v1))
    >>> v1_clone
    Vector([3.0, 4.0, 5.0])
    >>> v1 == v1_clone
    True


Tests of sequence behavior::

    >>> v1 = Vector([3, 4, 5])
    >>> len(v1)
    3
    >>> v1[0], v1[len(v1)-1], v1[-1]
    (3.0, 5.0, 5.0)


Test of slicing::

    >>> v7 = Vector(range(7))
    >>> v7[-1]
    6.0
    >>> v7[1:4]
    Vector([1.0, 2.0, 3.0])
    >>> v7[-1:]
    Vector([6.0])
    >>> v7[1,2]
    Traceback (most recent call last):
      ...
    TypeError: Vector indices must be integers


Tests of dynamic attribute access::

    >>> v7 = Vector(range(10))
    >>> v7.x
    0.0
    >>> v7.y, v7.z, v7.t
    (1.0, 2.0, 3.0)

Dynamic attribute lookup failures::

    >>> v7.k
    Traceback (most recent call last):
      ...
    AttributeError: 'Vector' object has no attribute 'k'
    >>> v3 = Vector(range(3))
    >>> v3.t
    Traceback (most recent call last):
      ...
    AttributeError: 'Vector' object has no attribute 't'
    >>> v3.spam
    Traceback (most recent call last):
      ...
    AttributeError: 'Vector' object has no attribute 'spam'


Tests of hashing::

    >>> v1 = Vector([3, 4])
    >>> v2 = Vector([3.1, 4.2])
    >>> v3 = Vector([3, 4, 5])
    >>> v6 = Vector(range(6))
    >>> hash(v1), hash(v3), hash(v6)
    (7, 2, 1)


Most hash values of non-integers vary from a 32-bit to 64-bit CPython build::

    >>> import sys
    >>> hash(v2) == (384307168202284039 if sys.maxsize > 2**32 else 357915986)
    True


Tests of ``format()`` with Cartesian coordinates in 2D::

    >>> v1 = Vector([3, 4])
    >>> format(v1)
    '(3.0, 4.0)'
    >>> format(v1, '.2f')
    '(3.00, 4.00)'
    >>> format(v1, '.3e')
    '(3.000e+00, 4.000e+00)'


Tests of ``format()`` with Cartesian coordinates in 3D and 7D::

    >>> v3 = Vector([3, 4, 5])
    >>> format(v3)
    '(3.0, 4.0, 5.0)'
    >>> format(Vector(range(7)))
    '(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0)'


Tests of ``format()`` with spherical coordinates in 2D, 3D and 4D::

    >>> format(Vector([1, 1]), 'h')  # doctest:+ELLIPSIS
    '<1.414213..., 0.785398...>'
    >>> format(Vector([1, 1]), '.3eh')
    '<1.414e+00, 7.854e-01>'
    >>> format(Vector([1, 1]), '0.5fh')
    '<1.41421, 0.78540>'
    >>> format(Vector([1, 1, 1]), 'h')  # doctest:+ELLIPSIS
    '<1.73205..., 0.95531..., 0.78539...>'
    >>> format(Vector([2, 2, 2]), '.3eh')
    '<3.464e+00, 9.553e-01, 7.854e-01>'
    >>> format(Vector([0, 0, 0]), '0.5fh')
    '<0.00000, 0.00000, 0.00000>'
    >>> format(Vector([-1, -1, -1, -1]), 'h')  # doctest:+ELLIPSIS
    '<2.0, 2.09439..., 2.18627..., 3.92699...>'
    >>> format(Vector([2, 2, 2, 2]), '.3eh')
    '<4.000e+00, 1.047e+00, 9.553e-01, 7.854e-01>'
    >>> format(Vector([0, 1, 0, 0]), '0.5fh')
    '<1.00000, 1.57080, 0.00000, 0.00000>'

Tests of new ``format()`` with length limit::

    >>> v5 = Vector(range(5))
    >>> v100 = Vector(range(100))
    >>> format(v5)
    '(0.0, 1.0, 2.0, 3.0, 4.0)'
    >>> format(v5, 'h')  # doctest:+ELLIPSIS
    '<5.477..., 1.5707..., 1.387..., 1.190..., 0.927...>'
    >>> format(v5, '0.3fh')
    '<5.477, 1.571, 1.387, 1.190, 0.927>'
    >>> format(v5, '*')
    '(0.0, 1.0, 2.0, 3.0, 4.0)'
    >>> format(v5, '.3f*')
    '(0.000, 1.000, 2.000, 3.000, 4.000)'
    >>> format(v5, '.3fh*')
    '<5.477, 1.571, 1.387, 1.190, 0.927>'

    >>> v30 = Vector(range(30))
    >>> format(v30)  # doctest:+ELLIPSIS
    '(0.0, 1.0, ..., 29.0)'
    >>> format(v30, 'h')  # doctest:+ELLIPSIS
    '<92.493..., 1.570..., ..., 0.802...>'
    >>> format(v30, '0.3fh')  # doctest:+ELLIPSIS
    '<92.493, 1.571, ..., 0.803>'
    >>> format(v30, '*')  # doctest:+ELLIPSIS
    '(0.0, 1.0, ..., 29.0)'
    >>> format(v30, '.3f*')  # doctest:+ELLIPSIS
    '(0.000, 1.000, ..., 29.000)'
    >>> format(v30, '.3fh*')  # doctest:+ELLIPSIS
    '<92.493, 1.571, ..., 0.803>'

    >>> v100 = Vector(range(100))
    >>> format(v100)  # doctest:+ELLIPSIS
    '(0.0, 1.0, ..., 29.0, ...)'
    >>> format(v100, 'h')  # doctest:+ELLIPSIS
    '<573.018..., 1.570..., ..., 1.521..., ...>'
    >>> format(v100, '0.3fh')  # doctest:+ELLIPSIS
    '<573.018, 1.571, ..., 1.521, ...>'
    >>> format(v100, '*')  # doctest:+ELLIPSIS
    '(0.0, 1.0, ..., 99.0)'
    >>> format(v100, '.3f*')  # doctest:+ELLIPSIS
    '(0.000, 1.000, ..., 99.000)'
    >>> format(v100, '.3fh*')  # doctest:+ELLIPSIS
    '<573.018, 1.571, ..., 0.790>'

    >>> v100.maxlen = 3
    >>> format(v100)
    '(0.0, 1.0, 2.0, ...)'
    >>> format(v100, 'h')  # doctest:+ELLIPSIS
    '<573.018..., 1.570..., 1.569..., ...>'
    >>> format(v100, '0.3fh')
    '<573.018, 1.571, 1.569, ...>'
    >>> format(v100, '*')  # doctest:+ELLIPSIS
    '(0.0, 1.0, ..., 99.0)'
    >>> format(v100, '.3f*')  # doctest:+ELLIPSIS
    '(0.000, 1.000, ..., 99.000)'
    >>> format(v100, '.3fh*')  # doctest:+ELLIPSIS
    '<573.018, 1.571, ..., 0.790>'
"""

from array import array
import reprlib
import math
import numbers
import functools
import operator
import itertools  # <1>


class Vector:
    typecode = 'd'

    def __init__(self, components):
        self._components = array(self.typecode, components)

    def __iter__(self):
        return iter(self._components)

    def __repr__(self):
        components = reprlib.repr(self._components)
        components = components[components.find('['):-1]
        return 'Vector({})'.format(components)

    def __str__(self):
        return str(tuple(self))

    def __bytes__(self):
        return (bytes([ord(self.typecode)]) +
                bytes(self._components))

    def __eq__(self, other):
        return (len(self) == len(other) and
                all(a == b for a, b in zip(self, other)))

    def __hash__(self):
        hashes = (hash(x) for x in self)
        return functools.reduce(operator.xor, hashes, 0)

    def __abs__(self):
        return math.hypot(*self)

    def __bool__(self):
        return any(x != 0 for x in self)

    def __len__(self):
        return len(self._components)

    def __getitem__(self, index):
        cls = type(self)
        if isinstance(index, slice):
            return cls(self._components[index])
        elif isinstance(index, numbers.Integral):
            return self._components[index]
        else:
            msg = '{.__name__} indices must be integers'
            raise TypeError(msg.format(cls))

    shortcut_names = 'xyzt'

    def __getattr__(self, name):
        cls = type(self)
        if len(name) == 1:
            pos = cls.shortcut_names.find(name)
            if 0 <= pos < len(self._components):
                return self._components[pos]
        msg = '{.__name__!r} object has no attribute {!r}'
        raise AttributeError(msg.format(cls, name))

    def angle(self, n):  # <2>
        r = math.sqrt(sum(x * x for x in self[n:]))
        a = math.atan2(r, self[n-1])
        if (n == len(self) - 1) and (self[-1] < 0):
            return math.pi * 2 - a
        else:
            return a

    def angles(self):  # <3>
        return (self.angle(n) for n in range(1, len(self)))

    maxlen = 30
    def __format__(self, fmt_spec=''):
        print_all = len(self) <= self.maxlen  # whether print all numbers
        if fmt_spec.endswith('*'):
            fmt_spec = fmt_spec[:-1]
            print_all = True
        if fmt_spec.endswith('h'):  # hyperspherical coordinates
            fmt_spec = fmt_spec[:-1]
            if print_all:
                coords = itertools.chain([abs(self)],
                                        self.angles())  # <4>
            else:
                coords = itertools.chain([abs(self)],
                                        itertools.islice(self.angles(), self.maxlen -1))
            outer_fmt = '<{}>'  # <5>
        else:
            if print_all:
                coords = self
            else:
                coords = itertools.islice(self, self.maxlen)
            outer_fmt = '({})'  # <6>
        components = (format(c, fmt_spec) for c in coords)  # <7>
        if not print_all:
            components = itertools.chain(components, ['...'])
        return outer_fmt.format(', '.join(components))  # <8>

    @classmethod
    def frombytes(cls, octets):
        typecode = chr(octets[0])
        memv = memoryview(octets[1:]).cast(typecode)
        return cls(memv)
# END VECTOR_V5