A memo for defining new derived class of the Element on SageMath

vector_space.sage

# -*- coding: utf-8 -*-
# vim: set ft=python expandtab :

class MyVecSpace(Parent):
    def __init__(self, base, dim=None):
        Parent.__init__(self, category=CommutativeAdditiveGroups().Finite())
        self._base = base
        self._dim = dim if dim is not None else 1

    def _repr_(self):
        return '{}-dimension vector space of {}'.format(self._dim, self._base)

    def _element_constructor_(self, vec_value):
        base = self._base
        assert len(vec_value) == self._dim
        assert all(((x in base) for x in vec_value)), 'Given: {}'.format(vec_value)
        return self.element_class(self, vec_value)

    @property
    def dimension(self):
        return self._dim

    def random_element(self):
        rand = self._base.random_element
        return self._element_constructor_([rand() for _ in range(self._dim)])

    class Element(sage.structure.element.Element):
        def __init__(self, given_parent, vec_value):
            sage.structure.element.Element.__init__(self, given_parent)
            self.vec_value = tuple(vec_value)

        def _repr_(self):
            return '{}'.format(self.vec_value)

        def _eq_(self, o):
            return all((x == y) for x, y in zip(self.vec_value, o.vec_value))

        def _ne_(self, o):
            return any((x != y) for x, y in zip(self.vec_value, o.vec_value))

        def _getitem_(self, key):
            return self.vec_value[key]
        __getitem__ = _getitem_

        def _setitem_(self, key, value):
            self.vec_value[key] = value
        __setitem__ = _setitem_

        def _iter_(self):
            vec = tuple(self.vec_value)
            for x in vec:
                yield x
        __iter__ = _iter_

        def _add_(self, o):
            vec_value = tuple([x + y for x, y in zip(self.vec_value, o.vec_value)])
            return self.__class__(self.parent(), vec_value)

        def _neg_(self):
            vec_value = tuple([-x for x in self.vec_value])
            return self.__class__(self.parent(), vec_value)

        def _sub_(self, o):
            vec_value = tuple([x - y for x, y in zip(self.vec_value, o.vec_value)])
            return self.__class__(self.parent(), vec_value)

        def _mul_(self, o):
            vec_value = tuple([x * o for x in self.vec_value])
            return self.__class__(self.parent(), vec_value)

        def _rmul_(self, o):
            vec_value = tuple([o * x for x in self.vec_value])
            return self.__class__(self.parent(), vec_value)

        def dot(self, o):
            vec_value = tuple([x * y for x, y in zip(self.vec_value, o.vec_value)])
            return self.__class__(self.parent(), vec_value)

def run_tests():
    Fp = GF(17)
    VS = MyVecSpace(Fp, 10)
    a = VS([1 for _ in range(VS.dimension)])
    print('      a = %s' % a)
    b = VS.random_element()
    print('      b = %s' % b)
    c = a + b
    print('  a + b = %s' % c)
    print('  b * 2 = %s' % (b * 2))
    print('  3 * b = %s' % (3 * b))
    print('b dot c = %s' % (b.dot(c)))
    print('list(b) = %s' % list(b))