Create an empty livetime cube.
3022
def create_empty(cls, tstart, tstop, fill=0.0, nside=64):
        """"""
        cth_edges = np.linspace(0, 1.0, 41)
        domega = utils.edge_to_width(cth_edges) * 2.0 * np.pi
        hpx = HPX(nside, True, 'CEL', ebins=cth_edges)
        data = np.ones((len(cth_edges) - 1, hpx.npix)) * fill
        return cls(data, hpx, cth_edges, tstart=tstart, tstop=tstop)
809250
def create(self, data, refresh=False):
        """"""
        self.__model__.create(self.__five9__, data)
        if refresh:
            return self.read(data[self.__model__.__name__])
        else:
            return self.new(data)
751588
def create(lr, weight_decay=0, momentum=0, layer_groups=False):
    
    return SgdFactory(lr=lr, weight_decay=weight_decay, momentum=momentum, layer_groups=layer_groups)
1355433
def create(self, width=0, depth=0, path=None, flags=0, seed=0):
        
        return self.create_method(self, width, depth, path, flags, seed)
566036
def empty(self, name, **kwargs):
        """"""
        return self._write_op(self._empty_nosync, name, **kwargs)
222723
def create(self, columns=None, type_map=None, overwrite=False):
        """"""
        # Check already exists #
        if self.count_bytes > 0:
            if overwrite: self.remove()
            else: raise Exception("File exists already at '%s'" % self)
        # If we want it empty #
        if columns is None:
            self.touch()
        # Make the table #
        else:
            self.add_table(self.main_table, columns=columns, type_map=type_map)
105396
def p_block_empty(self, p):
        ''
        p[0] = Block((), lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
668339
def empty( self, node ):
        """"""
        overall = self.overall( node )
        if overall:
            return (overall - self.children_sum( self.children(node), node))/float(overall)
        return 0
433744
def data(cls, cube, weighted, prune):
        """"""
        return cls()._data(cube, weighted, prune)
444183
def _create_blob(self):
        """"""
        blob = None
        for line in self.blob_file:
            line = try_decode_string(line)
            line = line.strip()
            if line == '':
                self.log.info("Ignoring empty line...")
                continue
            if line.startswith('end_event:') and blob:
                blob['raw_header'] = self.raw_header
                return blob
            try:
                tag, values = line.split(':')
            except ValueError:
                self.log.warning("Ignoring corrupt line: {}".format(line))
                continue
            try:
                values = tuple(split(values.strip(), callback=float))
            except ValueError:
                self.log.info("Empty value: {}".format(values))
            if line.startswith('start_event:'):
                blob = Blob()
                blob[tag] = tuple(int(v) for v in values)
                continue
            if tag not in blob:
                blob[tag] = []
            blob[tag].append(values)
1071497
def _create_blank_page(self):
        """"""
        loading_template = Template(BLANK)
        page = loading_template.substitute(css_path=self.css_path)
        return page
1276407
def _spawn_new(self, count=1):
        """"""
        free = self.free_cells()
        for x, y in random.sample(free, min(count, len(free))):
            self.grid[y][x] = random.randint(0, 10) and 2 or 4
148369
def zerosFactory(shape, dtype=float):
	
	arr = arrayFactory(shape=shape, dtype=dtype)
	arr.fill(0)
	return arr
544204
def create_turtle(self, id, shape, model_init, color_init):
        """"""
        assert id not in self.id_to_shape
        data = self._create_turtle(id, shape, model_init, color_init)
        self.id_to_shape[id] = shape
        return data
1064996
Node createEmptyFunction(JSType type) {
    Node result = NodeUtil.emptyFunction();
    if (isAddingTypes()) {
      checkNotNull(type);
      checkArgument(type.isFunctionType(), type);
      result.setJSType(checkNotNull(type));
    }
    return result;
  }
133747
def create_single(cls, value, idx='default'):
        

        return LabelList(idx=idx, labels=[
            Label(value=value)
        ])
119162
def propose_live(self):
        """"""

        i = self.rstate.randint(self.nlive)
        u = self.live_u[i, :]
        ax = np.identity(self.npdim) * self.radfriends.radius

        return u, ax