code: def cell_sizes_vecs(self):
          
          csizes = []
          for ax, cvec in enumerate(self.grid.coord_vectors):
              if len(cvec) == 1:
                  csizes.append(np.array([0.0]))
              else:
                  csize = np.empty_like(cvec)
                  csize[1:-1] = (cvec[2:] - cvec[:-2]) / 2.0
                  csize[0] = (cvec[0] + cvec[1]) / 2 - self.min()[ax]
                  csize[-1] = self.max()[ax] - (cvec[-2] + cvec[-1]) / 2
                  csizes.append(csize)
  
          return tuple(csizes)
docs: Return the cell sizes as coordinate vectors.
  
          Returns
          -------
          csizes : tuple of `numpy.ndarray`'s
              The cell sizes per axis. The length of the vectors is the
              same as the corresponding ``grid.coord_vectors``.
              For axes with 1 grid point, cell size is set to 0.0.
  
          Examples
          --------
          We create a partition of the rectangle [0, 1] x [-1, 2] into
          2 x 3 cells with the grid points [0, 1] x [-1, 0, 2]. This
          implies that the cell boundaries are given as
          [0, 0.5, 1] x [-1, -0.5, 1, 2], hence the cell size vectors
          are [0.5, 0.5] x [0.5, 1.5, 1]:
  
          >>> rect = odl.IntervalProd([0, -1], [1, 2])
          >>> grid = odl.RectGrid([0, 1], [-1, 0, 2])
          >>> part = odl.RectPartition(rect, grid)
          >>> part.cell_boundary_vecs
          (array([ 0. ,  0.5,  1. ]), array([-1. , -0.5,  1. ,  2. ]))
          >>> part.cell_sizes_vecs
          (array([ 0.5,  0.5]), array([ 0.5,  1.5,  1. ]))