Java Code Examples for tech.tablesaw.api.Table#rowCount()

private static Map<String, Double> getValueMap(
    CategoricalColumn<?> column1,
    CategoricalColumn<?> column2,
    NumericColumn<?> values,
    int valueIndex,
    TableSlice slice,
    AggregateFunction<?, ?> function) {

  Table temp = slice.asTable();
  Table summary = temp.summarize(values.name(), function).by(column1.name(), column2.name());

  Map<String, Double> valueMap = new HashMap<>();
  NumericColumn<?> nc = summary.numberColumn(summary.columnCount() - 1);
  for (int i = 0; i < summary.rowCount(); i++) {
    valueMap.put(String.valueOf(summary.get(i, 1)), nc.getDouble(i));
  }
  return valueMap;
}
 

@Test
public void testFilter3() {
  Table result =
      table.where(
          table
              .dateColumn("date")
              .isInApril()
              .and(table.numberColumn("approval").isGreaterThan(70)));

  DateColumn dates = result.dateColumn("date");
  ShortColumn approval = result.shortColumn("approval");
  for (int row = 0; row < result.rowCount(); row++) {
    assertTrue(PackedLocalDate.isInApril(dates.getIntInternal(row)));
    assertTrue(approval.get(row) > 70);
  }
}
 

/**
 * For a subtable that is grouped by the values in more than one column, split the grouping column
 * into separate cols and return the revised view
 */
private Table splitGroupingColumn(Table groupTable) {

  if (splitColumnNames.length > 0) {
    List<Column<?>> newColumns = new ArrayList<>();
    List<Column<?>> columns = sourceTable.columns(splitColumnNames);
    for (Column<?> column : columns) {
      Column<?> newColumn = column.emptyCopy();
      newColumns.add(newColumn);
    }
    // iterate through the rows in the table and split each of the grouping columns into multiple
    // columns
    for (int row = 0; row < groupTable.rowCount(); row++) {
      List<String> strings = SPLITTER.splitToList(groupTable.stringColumn("Group").get(row));
      for (int col = 0; col < newColumns.size(); col++) {
        newColumns.get(col).appendCell(strings.get(col));
      }
    }
    for (int col = 0; col < newColumns.size(); col++) {
      Column<?> c = newColumns.get(col);
      groupTable.insertColumn(col, c);
    }
    groupTable.removeColumns("Group");
  }
  return groupTable;
}
 

/**
 * For a subtable that is grouped by the values in more than one column, split the grouping column
 * into separate cols and return the revised view
 */
private Table splitGroupingColumn(Table groupTable) {

  if (splitColumnNames.length > 0) {
    List<Column<?>> newColumns = new ArrayList<>();
    List<Column<?>> columns = sourceTable.columns(splitColumnNames);
    for (Column<?> column : columns) {
      Column<?> newColumn = column.emptyCopy();
      newColumns.add(newColumn);
    }
    // iterate through the rows in the table and split each of the grouping columns into multiple
    // columns
    for (int row = 0; row < groupTable.rowCount(); row++) {
      List<String> strings = SPLITTER.splitToList(groupTable.stringColumn("Group").get(row));
      for (int col = 0; col < newColumns.size(); col++) {
        newColumns.get(col).appendCell(strings.get(col));
      }
    }
    for (int col = 0; col < newColumns.size(); col++) {
      Column<?> c = newColumns.get(col);
      groupTable.insertColumn(col, c);
    }
    groupTable.removeColumns("Group");
  }
  return groupTable;
}
 

private static Map<String, Double> getValueMap(
    CategoricalColumn<?> column1,
    CategoricalColumn<?> column2,
    NumericColumn<?> values,
    int valueIndex,
    TableSlice slice,
    AggregateFunction<?, ?> function) {

  Table temp = slice.asTable();
  Table summary = temp.summarize(values.name(), function).by(column1.name(), column2.name());

  Map<String, Double> valueMap = new HashMap<>();
  NumericColumn<?> nc = summary.numberColumn(summary.columnCount() - 1);
  for (int i = 0; i < summary.rowCount(); i++) {
    valueMap.put(String.valueOf(summary.get(i, 1)), nc.getDouble(i));
  }
  return valueMap;
}
 

@Test
public void testFilter3() {
  Table result =
      table.where(
          table
              .dateColumn("date")
              .isInApril()
              .and(table.numberColumn("approval").isGreaterThan(70)));

  DateColumn dates = result.dateColumn("date");
  ShortColumn approval = result.shortColumn("approval");
  for (int row = 0; row < result.rowCount(); row++) {
    assertTrue(PackedLocalDate.isInApril(dates.getIntInternal(row)));
    assertTrue(approval.get(row) > 70);
  }
}
 

/** Make sure each row in each table match */
public static void assertTableEquals(Table expected, Table actual) {
  assertEquals(actual.rowCount(), expected.rowCount(), "tables should have same number of rows");
  assertEquals(
      actual.columnCount(), expected.columnCount(), "tables should have same number of columns");
  int maxRows = actual.rowCount();
  int numberOfColumns = actual.columnCount();
  for (int rowIndex = 0; rowIndex < maxRows; rowIndex++) {
    for (int columnIndex = 0; columnIndex < numberOfColumns; columnIndex++) {
      assertEquals(
          actual.get(rowIndex, columnIndex),
          expected.get(rowIndex, columnIndex),
          "cells[" + rowIndex + ", " + columnIndex + "] do not match");
    }
  }
}
 

@Test
public void testSelectRange() {
  Table result = table.inRange(20, 30);
  assertEquals(10, result.rowCount());
  for (Column<?> c : result.columns()) {
    for (int r = 0; r < result.rowCount(); r++) {
      assertEquals(table.getString(r + 20, c.name()), result.getString(r, c.name()));
    }
  }
}
 

private SelectionTableSliceGroup(Table original, String subTableNameTemplate, int step) {
  super(original);
  List<Selection> selections = new ArrayList<>();
  for (int i = 0; i < original.rowCount() - step; i += step) {
    Selection selection = new BitmapBackedSelection();
    selection.addRange(i, i + step);
    selections.add(selection);
  }
  splitOnSelection(subTableNameTemplate, selections);
}
 

public static void tail(int rowsToInclude, Table oldTable, Table newTable) {
  int oldTableSize = oldTable.rowCount();
  int start = oldTableSize - rowsToInclude;
  Selection rows = new BitmapBackedSelection(rowsToInclude);
  for (int i = start; i < oldTableSize; i++) {
    rows.add(i);
  }
  copyRowsToTable(rows, oldTable, newTable);
}
 

public void write(Table table, HtmlWriteOptions options) throws IOException {
  ElementCreator elements = options.elementCreator();
  Element html = elements.create("table");
  html.appendChild(header(table.columns(), elements));

  Element tbody = elements.create("tbody");
  html.appendChild(tbody);
  for (int row = 0; row < table.rowCount(); row++) {
    tbody.appendChild(row(row, table, elements, options));
  }

  try (Writer writer = options.destination().createWriter()) {
    writer.write(html.toString());
  }
}
 

private static Table addFillerColumn(Table table, int numberColumnsToAdd, String prefix) {
  int[] filler = new int[table.rowCount()];
  Arrays.fill(filler, 1);
  IntColumn col = IntColumn.create("temp", filler);
  for (int i = 0; i < numberColumnsToAdd; i++) {
    table.addColumns(col.copy().setName(prefix + "_appendColumn" + i));
  }
  return table;
}
 

@Test
public void testCounts1() throws Exception {
  Table bush = Table.read().csv("../data/bush.csv");
  Table counts = CrossTab.counts(bush, "who");
  Table pcts = CrossTab.percents(bush, "who");
  double sum = counts.numberColumn("Count").sum();
  for (int row = 0; row < pcts.rowCount(); row++) {
    assertEquals(counts.intColumn("Count").get(row) / sum, pcts.doubleColumn(1).get(row), 0.01);
  }
}
 

protected String getTypeString(Table structure) {
  StringBuilder buf = new StringBuilder();
  buf.append("ColumnType[] columnTypes = {");
  buf.append(System.lineSeparator());

  Column<?> typeCol = structure.column("Column Type");
  Column<?> indxCol = structure.column("Index");
  Column<?> nameCol = structure.column("Column Name");

  // add the column headers
  int typeColIndex = structure.columnIndex(typeCol);
  int indxColIndex = structure.columnIndex(indxCol);
  int nameColIndex = structure.columnIndex(nameCol);

  int typeColWidth = typeCol.columnWidth();
  int indxColWidth = indxCol.columnWidth();
  int nameColWidth = nameCol.columnWidth();

  final char padChar = ' ';
  for (int r = 0; r < structure.rowCount(); r++) {
    String cell = Strings.padEnd(structure.get(r, typeColIndex) + ",", typeColWidth, padChar);
    buf.append(cell);
    buf.append(" // ");

    cell = Strings.padEnd(structure.getUnformatted(r, indxColIndex), indxColWidth, padChar);
    buf.append(cell);
    buf.append(' ');

    cell = Strings.padEnd(structure.getUnformatted(r, nameColIndex), nameColWidth, padChar);
    buf.append(cell);
    buf.append(' ');

    buf.append(System.lineSeparator());
  }
  buf.append("}");
  buf.append(System.lineSeparator());
  return buf.toString();
}
 

@Test
public void testCounts2() throws Exception {
  Table bush = Table.read().csv("../data/bush.csv");
  Table counts = CrossTab.counts(bush, "date");
  Table pcts = CrossTab.percents(bush, "date");
  double sum = counts.numberColumn("Count").sum();
  for (int row = 0; row < pcts.rowCount(); row++) {
    assertEquals(counts.intColumn("Count").get(row) / sum, pcts.doubleColumn(1).get(row), 0.01);
  }
}
 

@Test
public void testCounts1() throws Exception {
  Table bush = Table.read().csv("../data/bush.csv");
  Table counts = CrossTab.counts(bush, "who");
  Table pcts = CrossTab.percents(bush, "who");
  double sum = counts.numberColumn("Count").sum();
  for (int row = 0; row < pcts.rowCount(); row++) {
    assertEquals(counts.intColumn("Count").get(row) / sum, pcts.doubleColumn(1).get(row), 0.01);
  }
}
 

@Test
public void testRejectRange() {
  Table result = table.dropRange(20, 30);
  assertEquals(table.rowCount() - 10, result.rowCount());
  for (Column<?> c : result.columns()) {
    for (int r = 30; r < result.rowCount(); r++) {
      assertEquals(result.getString(r, c.name()), table.getString(r + 10, c.name()));
    }
  }
}
 

@Test
public void testCounts2() throws Exception {
  Table bush = Table.read().csv("../data/bush.csv");
  Table counts = CrossTab.counts(bush, "date");
  Table pcts = CrossTab.percents(bush, "date");
  double sum = counts.numberColumn("Count").sum();
  for (int row = 0; row < pcts.rowCount(); row++) {
    assertEquals(counts.intColumn("Count").get(row) / sum, pcts.doubleColumn(1).get(row), 0.01);
  }
}
 

private void addRows(
    ReadOptions options,
    ColumnType[] types,
    AbstractParser<?> reader,
    Table table,
    int[] columnIndexes,
    int sampleSize) {

  String[] nextLine;
  Map<String, AbstractColumnParser<?>> parserMap = getParserMap(options, table);

  Random random = new Random(0);
  // Add the rows
  for (int rowNumber = options.header() ? 1 : 0;
      (nextLine = reader.parseNext()) != null;
      rowNumber++) {
    // validation
    if (nextLine.length < types.length) {
      if (nextLine.length == 1 && Strings.isNullOrEmpty(nextLine[0])) {
        logger.error("Warning: Invalid file. Row " + rowNumber + " is empty. Continuing.");
        continue;
      } else {
        Exception e =
            new IndexOutOfBoundsException(
                "Row number "
                    + rowNumber
                    + " contains "
                    + nextLine.length
                    + " columns. "
                    + types.length
                    + " expected.");
        throw new AddCellToColumnException(e, 0, rowNumber, table.columnNames(), nextLine);
      }
    } else if (nextLine.length > types.length) {
      throw new IllegalArgumentException(
          "Row number "
              + rowNumber
              + " contains "
              + nextLine.length
              + " columns. "
              + types.length
              + " expected.");
    }

    int samplesCount = table.rowCount();
    if (sampleSize < 0 || samplesCount < sampleSize) {
      addValuesToColumns(table, columnIndexes, nextLine, parserMap, rowNumber, -1);
    } else {
      // find a row index to replace
      int randomIndex = random.nextInt(samplesCount + 1);
      // replace index if it is smaller than numSamples, otherwise ignore it.
      if (randomIndex < sampleSize) {
        addValuesToColumns(table, columnIndexes, nextLine, parserMap, rowNumber, randomIndex);
      }
    }
  }
}
 

private void addRows(
    ReadOptions options,
    ColumnType[] types,
    AbstractParser<?> reader,
    Table table,
    int[] columnIndexes,
    int sampleSize) {

  String[] nextLine;
  Map<String, AbstractColumnParser<?>> parserMap = getParserMap(options, table);

  Random random = new Random(0);
  // Add the rows
  for (int rowNumber = options.header() ? 1 : 0;
      (nextLine = reader.parseNext()) != null;
      rowNumber++) {
    // validation
    if (nextLine.length < types.length) {
      if (nextLine.length == 1 && Strings.isNullOrEmpty(nextLine[0])) {
        logger.error("Warning: Invalid file. Row " + rowNumber + " is empty. Continuing.");
        continue;
      } else {
        Exception e =
            new IndexOutOfBoundsException(
                "Row number "
                    + rowNumber
                    + " contains "
                    + nextLine.length
                    + " columns. "
                    + types.length
                    + " expected.");
        throw new AddCellToColumnException(e, 0, rowNumber, table.columnNames(), nextLine);
      }
    } else if (nextLine.length > types.length) {
      throw new IllegalArgumentException(
          "Row number "
              + rowNumber
              + " contains "
              + nextLine.length
              + " columns. "
              + types.length
              + " expected.");
    }

    int samplesCount = table.rowCount();
    if (sampleSize < 0 || samplesCount < sampleSize) {
      addValuesToColumns(table, columnIndexes, nextLine, parserMap, rowNumber, -1);
    } else {
      // find a row index to replace
      int randomIndex = random.nextInt(samplesCount + 1);
      // replace index if it is smaller than numSamples, otherwise ignore it.
      if (randomIndex < sampleSize) {
        addValuesToColumns(table, columnIndexes, nextLine, parserMap, rowNumber, randomIndex);
      }
    }
  }
}