protected Table createSubset(int[] rowSubset) { Table newbie = new Table(); newbie.setColumnTitles(columnTitles); // also sets columns.length newbie.columnTypes = columnTypes; newbie.setRowCount(rowSubset.length); for (int i = 0; i < rowSubset.length; i++) { int row = rowSubset[i]; for (int col = 0; col < columns.length; col++) { switch (columnTypes[col]) { case STRING: newbie.setString(i, col, getString(row, col)); break; case INT: newbie.setInt(i, col, getInt(row, col)); break; case LONG: newbie.setLong(i, col, getLong(row, col)); break; case FLOAT: newbie.setFloat(i, col, getFloat(row, col)); break; case DOUBLE: newbie.setDouble(i, col, getDouble(row, col)); break; } } } return newbie; }
/** * Same as getColumnIndex(), but creates the column if it doesn't exist. * Named this way to not conflict with checkColumn(), an internal function * used to ensure that a columns exists, and also to denote that it returns * an int for the column index. * @param title column title * @return index of a new or previously existing column */ public int checkColumnIndex(String title) { int index = getColumnIndex(title, false); if (index != -1) { return index; } addColumn(title); return getColumnCount() - 1; }
/** * version that uses a File object; future releases (or data types) * may include additional optimizations here * * @nowebref */ public Table(File file, String options) throws IOException { // uses createInput() to handle .gz (and eventually .bz2) files init(); parse(PApplet.createInput(file), extensionOptions(true, file.getName(), options)); }
public void addRows(Table source) { int index = getRowCount(); setRowCount(index + source.getRowCount()); for (TableRow row : source.rows()) { setRow(index++, row); } }
/** * @webref table:method * @brief Trims whitespace from values * @see Table#removeTokens(String) */ public void trim() { for (int col = 0; col < getColumnCount(); col++) { trim(col); } }
public Table typedParse(InputStream input, String options) throws IOException { Table table = new Table(); table.setColumnTypes(this); table.parse(input, options); return table; }
init(); try { ResultSetMetaData rsmd = rs.getMetaData(); setColumnCount(columnCount); setColumnTitle(col, rsmd.getColumnName(col + 1)); case Types.TINYINT: case Types.SMALLINT: setColumnType(col, INT); break; case Types.BIGINT: setColumnType(col, LONG); break; case Types.FLOAT: setColumnType(col, FLOAT); break; case Types.DECIMAL: case Types.DOUBLE: case Types.REAL: setColumnType(col, DOUBLE); break; for (int col = 0; col < columnCount; col++) { switch (columnTypes[col]) { case STRING: setString(row, col, rs.getString(col+1)); break; case INT: setInt(row, col, rs.getInt(col+1)); break; case LONG: setLong(row, col, rs.getLong(col+1)); break;
for (int col = 0; col < getColumnCount(); col++) { trim(col); int lastColumn = getColumnCount() - 1; while (isEmptyArray(getStringColumn(lastColumn)) && lastColumn >= 0) { lastColumn--; setColumnCount(lastColumn + 1); while (getColumnCount() > 0 && isEmptyArray(getStringColumn(0))) { removeColumn(0); int lastRow = lastRowIndex(); while (isEmptyArray(getStringRow(lastRow)) && lastRow >= 0) { lastRow--; setRowCount(lastRow + 1); while (getRowCount() > 0 && isEmptyArray(getStringRow(0))) { removeRow(0);
ensureColumn(dictionary.getRowCount() - 1); int titleCol = 0; int typeCol = 1; if (dictionary.hasColumnTitles()) { titleCol = dictionary.getColumnIndex("title", true); typeCol = dictionary.getColumnIndex("type", true); setColumnTitles(dictionary.getStringColumn(titleCol)); final String[] typeNames = dictionary.getStringColumn(typeCol); if (dictionary.getColumnCount() > 1) { if (getRowCount() > 1000) { int proc = Runtime.getRuntime().availableProcessors(); ExecutorService pool = Executors.newFixedThreadPool(proc/2); for (int i = 0; i < dictionary.getRowCount(); i++) { final int col = i; pool.execute(new Runnable() { for (int col = 0; col < dictionary.getRowCount(); col++) { setColumnType(col, typeNames[col]);
public Table[] getTable(ArrayList<Variable> selvars, DataRanges ranges) { DataRanges oranges = new DataRanges(ranges); Table datatab = new Table(); datatab.setMissingString(data.getMissingString()); datatab.addColumn(name, Table.STRING); if (mask[r]) count++; datatab.setRowCount(count); if (!mask[r0]) continue; TableRow src = data.getRow(r0); TableRow dest = datatab.getRow(r1); r1++; Table dicttab = new Table(); dicttab.setColumnCount(3); dicttab.setColumnType(0, Table.STRING); dicttab.setColumnType(1, Table.STRING); dicttab.setColumnType(2, Table.STRING); for (Variable var: selvars) { TableRow dest = dicttab.addRow(); dest.setString(0, var.getAlias()); dest.setString(1, Variable.formatType(var.type()));
@Override public float compare(int index1, int index2) { int a = reverse ? order[index2] : order[index1]; int b = reverse ? order[index1] : order[index2]; switch (getColumnType(column)) { case INT: return getInt(a, column) - getInt(b, column); case LONG: return getLong(a, column) - getLong(b, column); case FLOAT: return getFloat(a, column) - getFloat(b, column); case DOUBLE: return (float) (getDouble(a, column) - getDouble(b, column)); case STRING: return getString(a, column).compareToIgnoreCase(getString(b, column)); case CATEGORY: return getInt(a, column) - getInt(b, column); default: throw new IllegalArgumentException("Invalid column type: " + getColumnType(column)); } }
public Table(Iterable<TableRow> rows) { init(); setColumnTypes(incoming.getColumnTypes()); setColumnTitles(incoming.getColumnTitles()); setRowCount(alloc); setColumnCount(incoming.getColumnCount()); setRowCount(alloc); setRow(row++, incoming); setRowCount(row);
String kidName = kid.getName(); if (kidName == null) { odsAppendNotNull(kid, cellBuffer); odsAppendNotNull(kid, cellBuffer); cellBuffer.append(kid.getString("xlink:href")); } else { odsAppendNotNull(kid, cellBuffer); odsAppendNotNull(kid, cellBuffer); System.err.println(getClass().getName() + ": don't understand: " + kid); if (cellData != null) { setString(rowIndex, columnIndex, cellData); removeTitleRow(); // efficient enough on the first row header = false; // avoid infinite loop String[] rowStrings = getStringRow(rowIndex); for (int r = 1; r < rowRepeat; r++) { addRow(rowStrings);
public Table getProfile(ArrayList<Variable> selvars) { Table prof = new Table(); prof.setColumnCount(3); prof.setColumnType(0, Table.STRING); prof.setColumnType(1, Table.STRING); prof.setColumnType(2, Table.FLOAT); for (Variable var: selvars) { int idx = getColumn(var); if (idx == -1) continue; TableRow row = prof.addRow(); row.setString(0, var.getName()); row.setString(1, var.getAlias()); row.setFloat(2, getScore(getColumn(var))); } return prof; }
protected void sort(final int column, final boolean reverse) { final int[] order = IntList.fromRange(getRowCount()).array(); Sort s = new Sort() { for (int col = 0; col < getColumnCount(); col++) { switch (getColumnType(col)) { case INT: case CATEGORY: int[] oldInt = (int[]) columns[col]; int[] newInt = new int[rowCount]; for (int row = 0; row < getRowCount(); row++) { newInt[row] = oldInt[order[row]]; long[] oldLong = (long[]) columns[col]; long[] newLong = new long[rowCount]; for (int row = 0; row < getRowCount(); row++) { newLong[row] = oldLong[order[row]]; float[] oldFloat = (float[]) columns[col]; float[] newFloat = new float[rowCount]; for (int row = 0; row < getRowCount(); row++) { newFloat[row] = oldFloat[order[row]]; double[] oldDouble = (double[]) columns[col]; double[] newDouble = new double[rowCount]; for (int row = 0; row < getRowCount(); row++) { newDouble[row] = oldDouble[order[row]]; String[] oldString = (String[]) columns[col]; String[] newString = new String[rowCount];
protected void writeHTML(PrintWriter writer) { writer.println("<html>"); writer.println("<head>"); writer.println(" <meta http-equiv=\"content-type\" content=\"text/html;charset=utf-8\" />"); writer.println("</head>"); writer.println("<body>"); writer.println(" <table>"); for (int row = 0; row < getRowCount(); row++) { writer.println(" <tr>"); for (int col = 0; col < getColumnCount(); col++) { String entry = getString(row, col); writer.print(" <td>"); writeEntryHTML(writer, entry); writer.println(" </td>"); } writer.println(" </tr>"); } writer.println(" </table>"); writer.println("</body>"); writer.println("</hmtl>"); writer.flush(); }
/** * Searches the entire table for float values. * Returns missing float (Float.NaN by default) if no valid numbers found. */ protected float getMaxFloat() { boolean found = false; float max = PConstants.MIN_FLOAT; for (int row = 0; row < getRowCount(); row++) { for (int col = 0; col < getColumnCount(); col++) { float value = getFloat(row, col); if (!Float.isNaN(value)) { // TODO no, this should be comparing to the missing value if (!found) { max = value; found = true; } else if (value > max) { max = value; } } } } return found ? max : missingFloat; }
public void setColumnTypes(final Table dictionary) { ensureColumn(dictionary.getRowCount() - 1); int typeCol = 1; final String[] typeNames = dictionary.getStringColumn(typeCol); if (dictionary.getColumnCount() > 1) { if (getRowCount() > 1000) { int proc = Runtime.getRuntime().availableProcessors(); ExecutorService pool = Executors.newFixedThreadPool(proc/2); for (int i = 0; i < dictionary.getRowCount(); i++) { final int col = i; pool.execute(new Runnable() { public void run() { setColumnType(col, typeNames[col]); } }); } pool.shutdown(); while (!pool.isTerminated()) { Thread.yield(); } } else { for (int col = 0; col < dictionary.getRowCount(); col++) { setColumnType(col, typeNames[col]); } } } }
public IntDict getIntDict(String keyColumnName, String valueColumnName) { return new IntDict(getStringColumn(keyColumnName), getIntColumn(valueColumnName)); }
public FloatDict getFloatDict(String keyColumnName, String valueColumnName) { return new FloatDict(getStringColumn(keyColumnName), getFloatColumn(valueColumnName)); }