Return the ``<c:bubbleSize>`` element for this series as an oxml
        element. This element contains the bubble size values for this
        series.
967446
def bubbleSize(self):
        
        xml = self._bubbleSize_tmpl.format(**{
            'nsdecls':    ' %s' % nsdecls('c'),
            'numRef_xml': self.numRef_xml(
                self._series.bubble_sizes_ref, self._series.number_format,
                self._series.bubble_sizes
            ),
        })
        return parse_xml(xml)
799169
def getVoxelsScalar(self, vmin=None, vmax=None):
                
        nx, ny, nz = self.image.GetDimensions()
        
        voxdata = np.zeros([nx, ny, nz])
        lsx = range(nx)
        lsy = range(ny)
        lsz = range(nz)
        renorm = vmin is not None and vmax is not None
        for i in lsx:
            for j in lsy:
                for k in lsz:
                    s = self.image.GetScalarComponentAsFloat(i, j, k, 0)
                    if renorm:
                        s = (s - vmin) / (vmax - vmin)
                    voxdata[i, j, k] = s
        return voxdata
413078
public final long deepSizeOf(Object o) {

		IdentityHashMap<Object, Boolean> seenObjects = new IdentityHashMap<Object, Boolean>(10);
		return doDeepSizeOf(o, seenObjects);
	}
375172
def _get_size(self, node):
        
        if node == BLANK_NODE:
            return 0

        node_type = self._get_node_type(node)

        if is_key_value_type(node_type):
            value_is_node = node_type == NODE_TYPE_EXTENSION
            if value_is_node:
                return self._get_size(self._decode_to_node(node[1]))
            else:
                return 1
        elif node_type == NODE_TYPE_BRANCH:
            sizes = [self._get_size(self._decode_to_node(node[x]))
                     for x in range(16)]
            sizes = sizes + [1 if node[-1] else 0]
            return sum(sizes)
1206484
def _get_supercell_size(self, s1, s2):
        
        if self._supercell_size == 'num_sites':
            fu = s2.num_sites / s1.num_sites
        elif self._supercell_size == 'num_atoms':
            fu = s2.composition.num_atoms / s1.composition.num_atoms
        elif self._supercell_size == 'volume':
            fu = s2.volume / s1.volume
        else:
            try:
                el = get_el_sp(self._supercell_size)
                fu = s2.composition[el] / s1.composition[el]
            except:
                raise ValueError('Invalid argument for supercell_size.')

        if fu < 2/3:
            return int(round(1/fu)), False
        else:
            return int(round(fu)), True
416506
def free_size(self, units="MiB"):
        
        self.open()
        size = lvm_vg_get_free_size(self.handle)
        self.close()
        return size_convert(size, units)
638577
def volume(self):
        
        volume = float(np.product(self.primitive.extents))
        return volume
1146068
def calculate_pore_diameter(self):
        
        self.pore_diameter, self.pore_closest_atom = pore_diameter(
            self.elements, self.coordinates)
        self.properties['pore_diameter'] = {
            'diameter': self.pore_diameter,
            'atom': int(self.pore_closest_atom),
        }
        return self.pore_diameter
192719
def get_size(self):
        
        rec = self.get_rectangle()
        return (int(rec[2]-rec[0]), int(rec[3]-rec[1]))
1341196
def get_flat_size(self):
        
        return sum(
            np.prod(v.get_shape().as_list()) for v in self.variables.values())
186564
def getsize(o_file):
    
    startpos = o_file.tell()
    o_file.seek(0)
    o_file.seek(0, SEEK_END)
    size = o_file.tell()
    o_file.seek(startpos)
    return size
419848
def size(self):
        """"""
        size = {}
        if self._w3c:
            size = self._execute(Command.GET_ELEMENT_RECT)['value']
        else:
            size = self._execute(Command.GET_ELEMENT_SIZE)['value']
        new_size = {"height": size["height"],
                    "width": size["width"]}
        return new_size
343052
def get_size(self, m):
        
        nrow, ncol = 0, 0
        if m[0] == 'F':
            nrow = self.n
        elif m[0] == 'G':
            nrow = self.m

        if m[1] == 'x':
            ncol = self.n
        elif m[1] == 'y':
            ncol = self.m

        return nrow, ncol
91281
def getCol(self, x):
        """"""
        return [self.getCell(x, i) for i in self.__size_range]
867538
def get_size(self):
        
        raise NotImplementedError("%s not implemented for %s" % (self.get_size.__func__.__name__,
                                                                 self.__class__.__name__))
708728
def get_size(self):
    
    if not self._is_open:
      raise IOError('Not opened.')

    if self._decoded_stream_size is None:
      self._decoded_stream_size = self._GetDecodedStreamSize()

    return self._decoded_stream_size
302731
def sizes(self: Any) -> Mapping[Hashable, int]:
        
        return Frozen(OrderedDict(zip(self.dims, self.shape)))