<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def update(self, points, pointvol=0., rstate=None, bootstrap=0, pool=None, kdtree=None, mc_integrate=False):
 """ Update the half-side-lengths of our cubes. Parameters points : `~numpy.ndarray` with shape (npoints, ndim) The set of points to bound. pointvol : float, optional The minimum volume associated with each point. Default is `0.`. rstate : `~numpy.random.RandomState`, optional `~numpy.random.RandomState` instance. bootstrap : int, optional The number of bootstrapped realizations of the ellipsoids. The maximum distance to the set of points "left out" during each iteration is used to enlarge the resulting volumes. Default is `0`. pool : user-provided pool, optional Use this pool of workers to execute operations in parallel. kdtree : `~scipy.spatial.KDTree`, optional K-D Tree used to perform nearest neighbor searches. mc_integrate : bool, optional Whether to use Monte Carlo methods to compute the effective volume and fractional overlap of the final union of balls with the unit cube. Default is `False`. """


        if rstate is None:
            rstate = np.random

        # If possible, compute bootstraps in parallel using a pool.
        if pool is None:
            M = map
        else:
            M = pool.map

        if bootstrap == 0.:
            # Construct radius using leave-one-out if no bootstraps used.
            hsides = _friends_leaveoneout_radius(points, 'cubes')
        else:
            # Bootstrap radius using the set of live points.
            ps = [points for it in range(bootstrap)]
            ftypes = ['cubes' for it in range(bootstrap)]
            args = zip(ps, ftypes)
            hsides = list(M(_friends_bootstrap_radius, args))

        # Conservatively set radius to be maximum of the set.
        hsmax = max(hsides)
        self.hside = hsmax
        self.vol_cube = (2. * self.hside)**self.n
        self.expand = 1.

        # Expand our cube to encompass a minimum volume.
        if pointvol > 0.:
            v = pointvol
            if self.vol_cube < v:
                self.scale_to_vol(v)

        # Estimate the volume and fractional overlap with the unit cube
        # using Monte Carlo integration.
        if mc_integrate:
            self.vol, self.funit = self.monte_carlo_vol(points, kdtree=kdtree,
                                                        return_overlap=True)