Calculates the heights of each cell in the row.

@return the maximum height of the row.
14434
public float calculateHeights() {
		maxHeight = 0;
		for (int k = 0; k < cells.length; ++k) {
			PdfPCell cell = cells[k];
			float height = 0;
			if (cell == null) {
				continue;
			}
			else {
				height = cell.getMaxHeight();
				if ((height > maxHeight) && (cell.getRowspan() == 1))
					maxHeight = height;
			}
		}
		calculated = true;
		return maxHeight;
	}
743178
public static double[] rowMax(double[][] data) {
        double[] x = new double[data.length];

        for (int i = 0; i < x.length; i++) {
            x[i] = max(data[i]);
        }

        return x;
    }
683906
public double getMax() {
        double max = s.minValue();
        for (int c = 0; c < this.values.length; c++) {
            if (s.gte(values[c], max)) {
                max = values[c];
            }
        }
        return max;
    }
736981
@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
	public int getMaxHeight (){
		if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN)
			return mInputView.getMaxHeight();

		return -1;
	}
219072
private function calculateNumberOfColumns() {
        if (null !== $this->numberOfColumns) {
            return;
        }

        $columns = array(0);
        foreach (array_merge($this->headers, $this->rows) as $row) {
            if ($row instanceof Separator) {
                continue;
            }

            $columns[] = $this->getNumberOfColumns($row);
        }

        $this->numberOfColumns = max($columns);
    }
461916
public int findMax(PairDblInt[] cols) {
	int maxIdx = 0;
	double maxVal = -1.0;
	
	for (int i = 0; i < numLabels; i++) {
	    if (cols[i].first > maxVal) {
		maxVal = cols[i].first;
		maxIdx = i;
	    }
	}
	
	return maxIdx;
    }
1269996
private int findMaxRowLength(String maze[]){
        int max = 0;
        for (String rowMaze : maze) {
            if (rowMaze.length() > max) max = rowMaze.length();
        }
        return max;
    }
240727
private function calculateSizes()
    {
        // For each row...
        foreach ($this->data as $rowPosition => $rowContent) {
            // ... cycle each column to get its content ...
            foreach ($rowContent as $columnName => $cellContent) {
                // If we don't already know the height of this row...
                if (false === isset($this->rowsHeights[$rowPosition])) {
                    // ... we save the current calculated height
                    $this->rowsHeights[$rowPosition] = count($cellContent);
                }

                // Set the min_width if it is set
                if (isset($this->options['columns'][$columnName]['min_width'])) {
                    $this->columnsWidths[$columnName] = $this->options['columns'][$columnName]['min_width'];
                }

                // At this point we have the heigth for sure: on each cycle, we need the highest height
                if (count($cellContent) > $this->rowsHeights[$rowPosition]) {
                    /*
                     * The height of this row is the highest found: use this to set the height of the entire row.
                     */
                    $this->rowsHeights[$rowPosition] = count($cellContent);
                }

                // ... and calculate the length of each line to get the max length of the column
                foreach ($cellContent as $lineNumber => $lineContent) {
                    // Get the length of the cell
                    $contentLength = iconv_strlen($lineContent);

                    // If we don't already have a length for this column...
                    if (false === isset($this->columnsWidths[$columnName])) {
                        // ... we save the current calculated length
                        $this->columnsWidths[$columnName] = $contentLength;
                    }

                    // At this point we have a length for sure: on each cycle we need the longest length
                    if ($contentLength > $this->columnsWidths[$columnName]) {
                        /*
                         * The length of the content of this cell is longer than the value we already have.
                         * So we need to use this new value as length for the current column.
                         */
                        $this->columnsWidths[$columnName] = $contentLength;
                    }
                }
            }
        }
    }
560019
@Override
  protected int computeHeight() {
    N node = getRoot();
    int height = 1;

    // compute height
    while(!node.isLeaf() && node.getNumEntries() != 0) {
      E entry = node.getEntry(0);
      node = getNode(entry);
      height++;
    }
    return height;
  }
220784
def getMaxWidth(self, rows):
        ''
        w = 0
        if len(rows) > 0:
            w = max(max(len(self.getDisplayValue(r)) for r in rows), len(self.name))+2
        return max(w, len(self.name))
140582
function() {
                  var dim = this.dimensions();
                  var r = [];
                  for (var i = 1; i <= dim.cols; i++) {
                    r.push(this.col(i).sum() / dim.rows);
                  }
                  return $V(r);
                }
985631
private int calculateRowHeaderMaxWidth(DJCrosstabColumn crosstabColumn) {
		int auxWidth = 0;
		boolean firstTime = true;
		List<DJCrosstabColumn> auxList = new ArrayList<DJCrosstabColumn>(djcross.getColumns());
		Collections.reverse(auxList);
		for (DJCrosstabColumn col : auxList) {
			if (col.equals(crosstabColumn)){
				if (auxWidth == 0)
					auxWidth = col.getWidth();
				break;
			}

			if (firstTime){
				auxWidth += col.getWidth();
				firstTime = false;
			}
			if (col.isShowTotals()) {
				auxWidth += col.getWidth();
			}
		}
		return auxWidth;
	}
1143516
protected Set<?> getPrevExpandedRows() {
		Set<?> keys = getComponentModel().prevExpandedRows;
		if (keys == null) {
			return Collections.emptySet();
		} else {
			return Collections.unmodifiableSet(keys);
		}
	}
151168
private int getMaxHeight() {
        int result = 0;
        for (int i = 0; i < segmentCount; i++) {
            result = Math.max(result, segmentHeight(i, false));
        }
        return result;
    }
843774
private int getRowWidth() {
		int returnVal = 1;
		if (rows.size() < 1) {
			returnVal = 0;
		}
		for (int i = 0; i < rows.size(); i++) {
			if (rows.get(i) instanceof Row) {
				returnVal = ((Row) rows.get(i)).getRowWidth();
			}
		}
		return returnVal;
	}
1153219
private List<Integer> getColumnMaxWidths() {
    int numCols = data.get(0).size();
    int[] widths = new int[numCols];

    if (this.labels != null) {
      for (int i=0; i<numCols; i++) {
        widths[i] = this.labels.get(i).length();
      }
    }

    for (List<String> row : this.data) {
      for (int i=0;i<row.size(); i++) {
        if (row.get(i) == null) {
          widths[i] = Math.max(widths[i], 4);
        } else {
          widths[i] = Math.max(widths[i], row.get(i).length());
        }
      }
    }

    return Ints.asList(widths);
  }
129093
public ArrayList<String> getRows() {
		ArrayList<String> rows = new ArrayList<String>();
		for (String row : rowLookup.keySet()) {
			HeaderInfo hi = rowLookup.get(row);
			if (!hi.isHide()) {
				rows.add(row);
			}
		}
		return rows;
	}