def rebase(self, key, start=None, decimals=5):
        """Rebase a channel (key) on start.

        The step (between elements) need to be constant all through,
        else ValueError is raised. The exception to this is the border
        step between data loaded from two different files.

        key: int or str
            The key for the channel to rebase.

        start: int or float or None
            If specified - replace the first element in the first loaded
            data channel with start.

        decimals: int
            Diffs are rounded to this number of decimals before the step
            through arrays are checked. The diffs are otherwise likely never to
            be all equal.

        Typically this would be used to make a time channel
        continuous. Like, not start over from 0, when data is appended
        from multiple files. Or simply to rebase a channel on 'start'.

        If start is None, and the instance is loaded from one file only,
        this method has no effect.

        .. note::
           The instance channel is modified on success.

        """
        diffs = []

        def diffsappend(d, sc):
            diff = np.around(np.diff(d), decimals)
            diffs.append((diff, diff[0], sc))

        if hasattr(self, 'metamulti'):
            for sc in self.metamulti['slices']:
                diffsappend(self(key)[sc], sc)
        else:
            diffsappend(self(key), slice(0, self.rec_cnt))

        for diff, d, sc in diffs:
            if not np.all(diff == d):
                raise ValueError('All diffs not equal within ' +
                                 'indexes ' + str(sc))

        S = set([t[1] for t in diffs])
        if len(S) > 1:
            raise ValueError('Diffs not equal between appended data files: ' +
                             str(S))

        # Now modify:
        if start is None:
            start = self(key)[0]
        self.D[self._key(key)] = np.linspace(start, d * self.rec_cnt + start,
                                             num=self.rec_cnt, endpoint=False)

        assert len(self(key)) == self.rec_cnt, 'Semantic error'