'Return list of triples (eigenval, multiplicity, basis).
The flag ``simplify`` has two effects:
1) if bool(simplify) is True, as_content_primitive()
will be used to tidy up normalization artifacts;
2) if nullspace needs simplification to compute the
basis, the simplify flag will be passed on to the
nullspace routine which will interpret it there.
Parameters
error_when_incomplete : bool
Raise an error when not all eigenvalues are computed. This is
caused by ``roots`` not returning a full list of eigenvalues.
If the matrix contains any Floats, they will be changed to Rationals
for computation purposes, but the answers will be returned after being
evaluated with evalf. If it is desired to removed small imaginary
portions during the evalf step, pass a value for the ``chop`` flag.'

def eigenvects(self, error_when_incomplete=True, **flags):

    from sympy.matrices import eye
    simplify = flags.get('simplify', True)
    if (not isinstance(simplify, FunctionType)):
        simpfunc = (_simplify if simplify else (lambda x: x))
    primitive = flags.get('simplify', False)
    chop = flags.pop('chop', False)
    flags.pop('multiple', None)
    mat = self
    has_floats = any((v.has(Float) for v in self))
    if has_floats:
        mat = mat.applyfunc((lambda x: nsimplify(x, rational=True)))
    def eigenspace(eigenval):
        'Get    a    basis    for    the    eigenspace    for    a    particular    eigenvalue'
        m = (mat - (self.eye(mat.rows) * eigenval))
        ret = m.nullspace()
        if ((len(ret) == 0) and simplify):
            ret = m.nullspace(simplify=True)
        if (len(ret) == 0):
            raise NotImplementedError(("Can't    evaluate    eigenvector    for    eigenvalue    %s" % eigenval))
        return ret
    eigenvals = mat.eigenvals(rational=False, error_when_incomplete=error_when_incomplete, **flags)
    ret = [(val, mult, eigenspace(val)) for (val, mult) in sorted(eigenvals.items(), key=default_sort_key)]
    if primitive:
        def denom_clean(l):
            from sympy import gcd
            return [(v / gcd(list(v))).applyfunc(simpfunc) for v in l]
        ret = [(val, mult, denom_clean(es)) for (val, mult, es) in ret]
    if has_floats:
        ret = [(val.evalf(chop=chop), mult, [v.evalf(chop=chop) for v in es]) for (val, mult, es) in ret]
    return ret
