//table join operations Table Table::crossJoin(Table a, Table b) { Table t; vector<Attribute> a_columns = a.getColumns(); vector<Attribute> b_columns = b.getColumns(); for(int i = 0; i<a_columns.size(); i++){ t.addColumn(a_columns[i]); } for(int i = 0; i<b_columns.size(); i++){ t.addColumn(b_columns[i]); } for(int i = 0; i<a.getNumberOfRows(); i++){ for(int j = 0; j<b.getNumberOfRows(); j++){ vector<string> entries; for(int k = 0; k<a_columns.size(); k++){//a entries entries.push_back(a.rowAt(i).elementAt(k)); } for(int k = 0; k<b_columns.size(); k++){ entries.push_back(b.rowAt(j).elementAt(k)); } t.insertRow(entries); } } return t; }
Table *RunnerDB::getClubTB()//Table mode { bool canEdit = !oe->isClient(); if (clubTable == 0) { Table *table = new Table(oe, 20, "Klubbdatabasen", "clubdb"); table->addColumn("Id", 70, true, true); table->addColumn("Ändrad", 70, false); table->addColumn("Namn", 200, false); oClub::buildTableCol(oe, table); if (canEdit) table->setTableProp(Table::CAN_DELETE|Table::CAN_INSERT|Table::CAN_PASTE); else table->setTableProp(0); table->setClearOnHide(false); table->addOwnership(); clubTable = table; } int nr = 0; for (size_t k = 0; k < cdb.size(); k++) { if (!cdb[k].isRemoved()) nr++; } if (clubTable->getNumDataRows() != nr) clubTable->update(); return clubTable; }
bool Problem::isSatisfiable() const { Table table; table.empty(); table.addRow(); table.addColumn(ProblemConstants::cResultColumnName); table.setField(table.getCurrentRow(), ProblemConstants::cResultColumnName, 0); for (unsigned int i = 0; i < _variables.size(); i++) { table.addColumn(_variables[i].toString()); table.setField(table.getCurrentRow(), _variables[i].toString(), -1); } return simSat(table, 0); }
Table Table::naturalJoin(Table a, Table b) { Table t; vector<Attribute> a_keys = a.getKeys(); vector<Attribute> b_keys = b.getKeys(); vector<Attribute> matching_keys; for(int i = 0; i<a_keys.size(); i++){ for(int j = 0; j<b_keys.size(); j++){ if(a_keys[i].name == b_keys[j].name){ matching_keys.push_back(a_keys[i]); } } } if(matching_keys.size() > 0){ vector<Attribute> a_columns = a.getColumns(); vector<Attribute> b_columns = b.getColumns(); for(int i = 0; i<a_columns.size(); i++){ t.addColumn(a_columns[i]); } for(int i = 0; i<b_columns.size(); i++){ t.addColumn(b_columns[i]); //duplicate columns handled in this function } for(int i = 0; i<a.getNumberOfRows(); i++){ vector<string> entries; for(int j = 0; j<a.getColumns().size(); j++){ entries.push_back(a.rowAt(i).elementAt(j)); } string key_value = a.rowAt(i).elementAt(a.getKeyIndex(matching_keys[0].name)); //for now, just handle first matching key for(int j = 0; j<b.getNumberOfRows(); j++){ if(key_value == b.rowAt(j).elementAt(b.getKeyIndex(matching_keys[0].name))){ //key_value matches row in table b for(int k = 0; k<b.getColumns().size(); k++){ //add all other contents of matching row if(k != b.getKeyIndex(matching_keys[0].name)){ entries.push_back(b.rowAt(j).elementAt(k)); } } break; } } //if matching rows are joined, add to the new table if(entries.size() != a.getColumns().size()){ t.insertRow(entries); } } return t; } else{ throw NoMatchingKeysException(); } }
void fillTable( const std::vector<Path>& items ) { unsigned int columnCount = table->width() / 150; table->setRowHeight( 150 ); if( items.size() < columnCount ) columnCount = items.size(); for( unsigned int k=0; k < columnCount; k++ ) { table->addColumn( "" ); table->setColumnWidth( table->columnCount()-1, 150 ); } for( unsigned int k=0; k < items.size(); k++ ) { int rowNumber = k / columnCount; int columnNumber = k % columnCount; if( rowNumber >= table->rowCount() ) { table->addRow( rowNumber ); } Path picPath = items[ k ]; if( available.contains( picPath.extension() ) ) { picPath = picPath.changeExtension( "png" ); } Picture pic = PictureLoader::instance().load( vfs::NFile::open( picPath ) ); Image* image = new Image( table, Rect( 0, 0, 140, 140 ), pic, Image::best ); table->addElementToCell( rowNumber, columnNumber, image ); table->setCellData( rowNumber, columnNumber, "path", items[ k ].toString() ); } }
std::ostream & Dashboard::print(std::ostream & os) { Table myTable; myTable.addColumn("timername","Timer Name",Table::JUSTIFIED_LEFT,Table::JUSTIFIED_LEFT); myTable.addColumn("elapsed","ms",'.',Table::JUSTIFIED_MIDDLE,4); myTable.addColumn("average","avrg.",'.',Table::JUSTIFIED_MIDDLE,4); myTable.addColumn("minimum","min.",'.',Table::JUSTIFIED_MIDDLE,4); myTable.addColumn("maximum","max.",'.',Table::JUSTIFIED_MIDDLE,4); myTable.addColumn("intervals","i",Table::JUSTIFIED_RIGHT); myTable.addColumn("persec","i/sec",Table::JUSTIFIED_MIDDLE); myTable.addColumn("cycles","cyc.",Table::JUSTIFIED_RIGHT); printTimers(myTable); myTable.print(os); if (!_myCounters.empty()) { Table myCounterTable; myCounterTable.addColumn("countername","Counter Name",Table::JUSTIFIED_LEFT); myCounterTable.addColumn("count","Count",'.'); myCounterTable.addColumn("cycles","Cycles",Table::JUSTIFIED_MIDDLE); for (std::map<std::string,CounterPtr>::iterator it=_myCounters.begin(); it != _myCounters.end(); ++it) { myCounterTable.addRow(); const asl::Counter & myCounter = _myCompleteCycleCounters[it->first]; unsigned long myCycleCount = _myGroupCounters[myCounter.getGroup()].getCount(); myCounterTable.setField("countername",it->first); if (myCycleCount > 1) { myCounterTable.setField("count",as_string(myCounter.getCount())); // we do not want an averaged counter (vs) //myCounterTable.setField("count",as_string(myCounter.getCount() / myCycleCount )); myCounterTable.setField("cycles",as_string(myCycleCount)); } else { myCounterTable.setField("count",as_string(myCounter.getCount())); myCounterTable.setField("cycles","incomplete"); } } myCounterTable.print(os); } return os; }
bool NdbInfo::addColumn(Uint32 tableId, Column aCol) { Table * table = NULL; // Find the table with correct id for (size_t i = 0; i < m_tables.entries(); i++) { table = m_tables.value(i); if (table->m_table_id == tableId) break; } table->addColumn(aCol); return true; }
void InvokeCommand::fillTableArg(Table & tableArg, const mArray &tableArray) { for (mArray::const_iterator i = tableArray.begin(); i != tableArray.end(); ++i) { const mArray rowArray = i->get_array(); if (i == tableArray.begin()) { // the first row are the columns for (mArray::const_iterator j = rowArray.begin(); j != rowArray.end(); ++j) { tableArg.addColumn(j->get_str()); } } else { Table::row_type row; for (mArray::const_iterator j = rowArray.begin(); j != rowArray.end(); ++j) { row.push_back(j->get_str()); } tableArg.addRow(row); } } }
void Solver::tableBasicArtificialStep(Table& instance, int* rowBasis) { if (_excessiveLogging) { printf("------------------------------------------\n"); printf("- BASIC INFO -\n"); printf("------------------------------------------\n"); } //Calculate all existing basic data findBasicInfo(instance, rowBasis); //First row is the objective function, should have no basic variables for (unsigned int i = 1; i < instance.getNumRows(); i++) { //If a row has no basic column then insert an artificial variable to compensate if (rowBasis[i] == -1) { int col = instance.addColumn(std::string("artificial") + std::to_string(_lastArtificial++), true); instance.setField(i, col, 1); rowBasis[i] = col; if (_excessiveLogging) { printf("DEBUG: Failed to find basic variable for row %i\n", i); printf("DEBUG: Creating artificial variable for row %i\n", i); instance.print(); } } if (_excessiveLogging) { double basicField = instance.getField(i, rowBasis[i]); double resultField = instance.getField(i, 0); printf("DEBUG: Row %i: Col %i is basic (Solution: %f/%f -> %f)\n", i, rowBasis[i], instance.getField(i, rowBasis[i]), instance.getField(i, 0), resultField == 0 ? 0 : basicField / resultField); } } if (_excessiveLogging) { printf("------------------------------------------\n"); } }