This method reverses the StridedInterval object for real. Do expect loss of precision for most cases!

        :return: A new reversed StridedInterval instance

def _involuted_reverse(self):
        """
        This method reverses the StridedInterval object for real. Do expect loss of precision for most cases!

        :return: A new reversed StridedInterval instance
        """
        def inv_is_top(si):
            return (si.stride == 1 and
                self._lower_bound == StridedInterval._modular_add(self._upper_bound, 1, self.bits)
                )

        o = self.copy()
        # Clear the reversed flag
        o._reversed = not o._reversed

        if o.bits == 8:
            # No need for reversing
            return o.copy()

        if inv_is_top(o):
            # A TOP is still a TOP after reversing
            si = o.copy()
            return si

        else:
            lb = o._lower_bound
            ub = o._upper_bound

            rounded_bits = ((o.bits + 7) // 8) * 8
            lb_r = []
            ub_r = []

            for i in xrange(0, rounded_bits, 8):
                if i != 0:
                    lb = lb >> 8
                    ub = ub >> 8

                lb_r.append(lb & 0xff)
                ub_r.append(ub & 0xff)

            si_lb = None
            si_ub = None
            for b in lb_r:
                if si_lb is None:
                    si_lb = b
                else:
                    si_lb <<= 8
                    si_lb |= b
            for b in ub_r:
                if si_ub is None:
                    si_ub = b
                else:
                    si_ub <<= 8
                    si_ub |= b

            si = StridedInterval(bits=o.bits,
                                 lower_bound=si_lb,
                                 upper_bound=si_ub,
                                 stride=o._stride,
                                 uninitialized=o.uninitialized)

            si._reversed = o._reversed
            if not o.is_integer:
                # We really don't want to do that... but well, sometimes it just happens...
                logger.warning('Reversing a real strided-interval %s is bad', self)

            return si