//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");
}
}