returns each formula in the selected sheet as an array of tuples in following format
 [[row, col, formula], [row, col, formula],...]
968075
def formulas(sheet = nil)
      sheet_for(sheet).cells.select { |_, cell| cell.formula }.map do |(x, y), cell|
        [x, y, cell.formula]
      end
    end
131834
def get_all_values(self):
        

        data = self.spreadsheet.values_get(self.title)

        try:
            return fill_gaps(data['values'])
        except KeyError:
            return []
964776
def getcellslice(self, rownr, blc, trc, inc=[]):
        """"""
        return self._table.getcellslice(self._column, rownr, blc, trc, inc)
361353
def column_names sheet
    
      names = []
      
      titles = sheet.column_titles
      
      sheet.each_cell_definition do |column, i|
      
        if titles[i]

          names << titles[i]
          
        elsif column.respond_to?(:value_name)
          
          names << column.value_name
          
        else
          
          names << nil
          
        end
        
      end
      
      names
      
    end
317041
def select_rows(self, rows):
        
        if not isinstance(rows, (list, tuple)): rows = [rows]
        return self.__class__([p for p in self if p.element.row in rows])
1257932
def parse_row(self, row, row_index, cell_mode=CellMode.cooked):
    """"""
    return [self.parse_cell(cell, (col_index, row_index), cell_mode) \
            for col_index, cell in enumerate(row)]
28552
def worksheets(self):
        
        sheet_data = self.fetch_sheet_metadata()
        return [Worksheet(self, x['properties']) for x in sheet_data['sheets']]
1277892
public static Cell[] getColumn(final Sheet sheet, final int col) {
        ArgUtils.notNull(sheet, "sheet");

        int maxRow = getRows(sheet);
        Cell[] cells = new Cell[maxRow];
        for(int i=0; i < maxRow; i++) {
            Row rows = sheet.getRow(i);
            if(rows == null) {
                rows = sheet.createRow(i);

            }

            Cell cell = rows.getCell(col);
            if(cell == null) {
                cell = rows.createCell(col, CellType.BLANK);
            }

            cells[i] = cell;
        }

        return cells;
    }
50851
def rows(self, cell_mode=CellMode.cooked):
    
    for row_index in range(self.nrows):
      yield self.parse_row(self.get_row(row_index), row_index, cell_mode)
1122218
def get_range_data(row_start, col_start, row_end, col_end) # :nodoc:
      # TODO. Check for worksheet limits.

      # Iterate through the table data.
      data = []
      (row_start .. row_end).each do |row_num|
        # Store nil if row doesn't exist.
        if !@cell_data_table[row_num]
          data << nil
          next
        end

        (col_start .. col_end).each do |col_num|
          if cell = @cell_data_table[row_num][col_num]
            data << cell.data
          else
            # Store nil if col doesn't exist.
            data << nil
          end
        end
      end

      return data
    end
1115681
def to_array(self):
        """"""
        dt = np.dtype(list(zip(self.labels, (c.dtype for c in self.columns))))
        arr = np.empty_like(self.columns[0], dt)
        for label in self.labels:
            arr[label] = self[label]
        return arr
906397
def getcols(sheetMatch=None,colMatch="Decay"):
    """"""
    book=BOOK()
    if sheetMatch is None:
        matchingSheets=book.sheetNames
        print('all %d sheets selected '%(len(matchingSheets)))
    else:
        matchingSheets=[x for x in book.sheetNames if sheetMatch in x]
        print('%d of %d sheets selected matching "%s"'%(len(matchingSheets),len(book.sheetNames),sheetMatch))
    matchingSheetsWithCol=[]
    for sheetName in matchingSheets:
        i = book.sheetNames.index(sheetName) # index of that sheet
        for j,colName in enumerate(book.sheets[i].colDesc):
            if colMatch in colName:
                matchingSheetsWithCol.append((sheetName,j))
                break
        else:
            print("  no match in [%s]%s"%(book.bookName,sheetName))
    print("%d of %d of those have your column"%(len(matchingSheetsWithCol),len(matchingSheets)))
    for item in matchingSheetsWithCol:
        print(item,item[0],item[1])
259144
def format_row(self, row):
        
        res = []
        headers = getattr(self, 'headers', [])
        for column in headers:
            column_name = column['name']
            value = row.get(column_name, '')
            if hasattr(self, "format_%s" % column_name):
                value = getattr(self, "format_%s" % column_name)(value)
            res.append(value)
        return res
1066351
public Formula getFormula() {
		Reagent[] reagents = new Reagent[] {KEY, VALUE, PARENT, EXPRESSION};
		final Formula rslt = new SimpleFormula(getClass(), reagents);
		return rslt;
	}
136266
def toArray(self):
        
        if self.isTransposed:
            return np.asfortranarray(
                self.values.reshape((self.numRows, self.numCols)))
        else:
            return self.values.reshape((self.numRows, self.numCols), order='F')
466383
def findall(self, title=None):
        
        if title is None:
            return list(self._sheets)
        if title not in self._titles:
            return []
        return list(self._titles[title])
260049
def get_cell_lines(self, column_idx):
        '''
            
        '''
        return [] if column_idx >= len(self.columns) else self.columns[column_idx].get_cell_lines()