The Excel worksheet reference to the range containing the bubble
        sizes for *series* (not including the column heading cell).
348651
def bubble_sizes_ref(self, series):
        
        top_row = self.series_table_row_offset(series) + 2
        bottom_row = top_row + len(series) - 1
        return "Sheet1!$C$%d:$C$%d" % (top_row, bottom_row)
52739
def _xls2col_widths(self, worksheet, tab):
        """"""

        for col in xrange(worksheet.ncols):
            try:
                xls_width = worksheet.colinfo_map[col].width
                pys_width = self.xls_width2pys_width(xls_width)
                self.code_array.col_widths[col, tab] = pys_width

            except KeyError:
                pass
1366892
public ExcelWriter autoSizeColumnAll() {
		final int columnCount = this.getColumnCount();
		for (int i = 0; i < columnCount; i++) {
			autoSizeColumn(i);
		}
		return this;
	}
37963
def output_size(self) -> Tuple[Sequence[Shape], Sequence[Shape], Sequence[Shape], int]:
        ''''''
        return self._cell.output_size
154323
def roc(series, window=14):
    
    res = (series - series.shift(window)) / series.shift(window)
    return pd.Series(index=series.index, data=res)
91281
def getCol(self, x):
        """"""
        return [self.getCell(x, i) for i in self.__size_range]
1197137
def wr_xlsx(self, fout_xlsx):
        """"""
        from goatools.wr_tbl import wr_xlsx
        kws = {
            'title' : self.title,
            'hdrs' :["Dep/Lev",
                     "BP Depth", "MF Depth", "CC Depth",
                     "BP Level", "MF Level", "CC Level"]}
        wr_xlsx(fout_xlsx, self.get_data(), **kws)
1329783
def values(self):
        
        # TODO: Figure out how to intersperse pairwise objects for columns
        # that represent H&S
        return [
            _ColumnPairwiseSignificance(
                self._slice,
                col_idx,
                self._axis,
                self._weighted,
                self._alpha,
                self._only_larger,
                self._hs_dims,
            )
            for col_idx in range(self._slice.get_shape(hs_dims=self._hs_dims)[1])
        ]
966710
def bubbleSize_xml(self):
        
        return self._bubbleSize_tmpl.format(**{
            'nsdecls':    '',
            'numRef_xml': self.numRef_xml(
                self._series.bubble_sizes_ref, self._series.number_format,
                self._series.bubble_sizes
            ),
        })
272683
public int size()
    {
        int ret = 0;
        for(Collection<LineSeriesItem<I,V>> series : data)
        {
            if(series.size() > 0)
                ++ret;
        }
        return ret;
    }
513322
def categories_ref(self):
        
        categories = self._chart_data.categories
        if categories.depth == 0:
            raise ValueError('chart data contains no categories')
        right_col = chr(ord('A') + categories.depth - 1)
        bottom_row = categories.leaf_count + 1
        return "Sheet1!$A$2:$%s$%d" % (right_col, bottom_row)
899144
def with_sizes(self, *headers):
        ''''''
        if len(headers) != 5:
            raise ValueError('You need to provide this headers: class, method, times, total, average')

        summary = self.summary()

        for row in summary.values():
            sizes = [len(header) for header in headers]
            # Benchmark/Class column
            sizes[0] = max(sizes[0], len(row['name']))
            # Method column
            max_length = max(len(r['name']) for r in row['runs'].values())
            sizes[1] = max(sizes[1], max_length)
            # Times column
            sizes[2] = max(sizes[2], len(str(row['times'])))
            # Float columns
            for idx, field in [(3, 'total'), (4, 'mean')]:
                float_len = lambda r: len(self.float(r[field]))
                max_length = max(float_len(r) for r in row['runs'].values())
                sizes[idx] = max(sizes[idx], max_length)
            row['sizes'] = sizes

        return summary
754684
def convert_range3d(token, _class)
    # Split the ref at the ! symbol
    ext_ref, range = token.split('!')

    # Convert the external reference part
    ext_ref = pack_ext_ref(ext_ref)

    # Split the range into 2 cell refs
    cell1, cell2 = range.split(':')

    # A range such as A:D is equivalent to A1:D65536, so add rows as required
    cell1 += '1'     unless cell1 =~ /\d/
    cell2 += '65536' unless cell2 =~ /\d/

    # Convert the cell references
    row1, col1 = cell_to_packed_rowcol(cell1)
    row2, col2 = cell_to_packed_rowcol(cell2)

    # The ptg value depends on the class of the ptg.
    if    (_class == 0)
      ptgarea = [@ptg['ptgArea3d']].pack("C")
    elsif (_class == 1)
      ptgarea = [@ptg['ptgArea3dV']].pack("C")
    elsif (_class == 2)
      ptgarea = [@ptg['ptgArea3dA']].pack("C")
    else
      exit "Unknown function class in formula\n"
    end

    ptgarea + ext_ref + row1 + row2 + col1+ col2
  end
546303
function (d, chart, series) {
            var returnR = 0,
                scaleFactor = 1;
            if (series.z === null || series.z === undefined) {
                returnR = (!series.radius || series.radius === "auto" ? 5 : series.radius);
            } else {
                if (series.radius && series.radius !== "auto" && series.radius > 1) {
                    scaleFactor = series.radius / series.z._scale(series.z._max);
                }
                if (series.z._hasMeasure()) {
                    returnR = series.z._scale(d.r) * scaleFactor;
                } else {
                    returnR = series.z._scale(chart._heightPixels() / 100) * scaleFactor;
                }
            }
            return returnR;
        }
723177
def column(self):
        
        for i in my_xrange(self._column_query_pos, self.pos):
            if self.text[i] == '\t':
                self._column += self.tab_size
                self._column -= self._column % self.tab_size
            else:
                self._column += 1
        self._column_query_pos = self.pos
        return self._column
1182809
function getCellByRange(range) {
  let cell = range.startContainer;

  if (domUtils.getNodeName(cell) === 'TD' || domUtils.getNodeName(cell) === 'TH') {
    cell = $(cell);
  } else {
    cell = $(cell).parentsUntil('tr');
  }

  return cell;
}
1014433
def _SeriesFactory(ser):
    
    xChart_tag = ser.getparent().tag

    try:
        SeriesCls = {
            qn('c:areaChart'):     AreaSeries,
            qn('c:barChart'):      BarSeries,
            qn('c:bubbleChart'):   BubbleSeries,
            qn('c:doughnutChart'): PieSeries,
            qn('c:lineChart'):     LineSeries,
            qn('c:pieChart'):      PieSeries,
            qn('c:radarChart'):    RadarSeries,
            qn('c:scatterChart'):  XySeries,
        }[xChart_tag]
    except KeyError:
        raise NotImplementedError(
            'series class for %s not yet implemented' % xChart_tag
        )

    return SeriesCls(ser)