void test_rows() { // Create a table named "Table". auto db = grnxx::open_db(""); auto table = db->create_table("Table"); // Append the first row. grnxx::Int row_id = table->insert_row(); assert(row_id.raw() == 0); assert(table->num_rows() == 1); assert(table->max_row_id().match(row_id)); assert(!table->test_row(grnxx::Int(-1))); assert(table->test_row(grnxx::Int(0))); assert(!table->test_row(grnxx::Int(1))); // Append two more rows. assert(table->insert_row().raw() == 1); assert(table->insert_row().raw() == 2); assert(table->num_rows() == 3); assert(table->max_row_id().raw() == 2); assert(table->test_row(grnxx::Int(0))); assert(table->test_row(grnxx::Int(1))); assert(table->test_row(grnxx::Int(2))); assert(!table->test_row(grnxx::Int(3))); // Remove the second row. table->remove_row(grnxx::Int(1)); assert(table->num_rows() == 2); assert(table->max_row_id().raw() == 2); assert(table->test_row(grnxx::Int(0))); assert(!table->test_row(grnxx::Int(1))); assert(table->test_row(grnxx::Int(2))); assert(!table->test_row(grnxx::Int(3))); // Remove the first row. table->remove_row(grnxx::Int(0)); assert(table->num_rows() == 1); assert(table->max_row_id().raw() == 2); assert(!table->test_row(grnxx::Int(0))); assert(!table->test_row(grnxx::Int(1))); assert(table->test_row(grnxx::Int(2))); assert(!table->test_row(grnxx::Int(3))); // Remove the third row. table->remove_row(grnxx::Int(2)); assert(table->num_rows() == 0); assert(table->max_row_id().is_na()); assert(!table->test_row(grnxx::Int(0))); assert(!table->test_row(grnxx::Int(1))); assert(!table->test_row(grnxx::Int(2))); assert(!table->test_row(grnxx::Int(3))); }
void test_reference() { // Create tables. auto db = grnxx::open_db(""); auto to_table = db->create_table("To"); auto from_table = db->create_table("From"); // Create a column named "Ref". grnxx::ColumnOptions options; options.reference_table_name = "To"; auto ref_column = from_table->create_column("Ref", GRNXX_INT, options); // Append rows. to_table->insert_row(); to_table->insert_row(); to_table->insert_row(); from_table->insert_row(); from_table->insert_row(); from_table->insert_row(); ref_column->set(grnxx::Int(0), grnxx::Int(0)); ref_column->set(grnxx::Int(1), grnxx::Int(1)); ref_column->set(grnxx::Int(2), grnxx::Int(1)); // TODO: "from_table" may be updated in "to_table->remove_row()". to_table->remove_row(grnxx::Int(0)); grnxx::Datum datum; ref_column->get(grnxx::Int(0), &datum); assert(datum.type() == GRNXX_INT); assert(datum.as_int().raw() == 0); ref_column->get(grnxx::Int(1), &datum); assert(datum.type() == GRNXX_INT); assert(datum.as_int().raw() == 1); ref_column->get(grnxx::Int(2), &datum); assert(datum.type() == GRNXX_INT); assert(datum.as_int().raw() == 1); to_table->remove_row(grnxx::Int(1)); ref_column->get(grnxx::Int(0), &datum); assert(datum.type() == GRNXX_INT); assert(datum.as_int().raw() == 0); ref_column->get(grnxx::Int(1), &datum); assert(datum.type() == GRNXX_INT); assert(datum.as_int().raw() == 1); ref_column->get(grnxx::Int(2), &datum); assert(datum.type() == GRNXX_INT); assert(datum.as_int().raw() == 1); }
void detect_lines(void) { unsigned int row_index; unsigned int count = 0; for (row_index = 0; row_index < NUMBER_OF_ROWS; row_index++) { if (is_row_completed(row_index)) { remove_row(row_index); count++; } } if (count > 0) { set_score(get_score() + 1 << (2 * (count - 1))); } }
int SparseSystem::add_row_givens(const SparseVector& new_row, double new_r) { // set new row (also translates according to current variable ordering) add_row(new_row, new_r); int count = 0; int row = num_rows() - 1; // last row int col = get_row(row).first(); // first entry to be zeroed while (col>=0 && col<row) { // stop when we reach the diagonal apply_givens(row, col); count++; col = get_row(row).first(); } if (get_row(row).nnz()==0) { // need to remove the new row as it is now empty remove_row(); // and the rhs needs to be cut accordingly VectorXd v = _rhs.segment(0, row); // temporary variable is necessary because of aliasing in Eigen _rhs = v; } return count; }
PointInPolygonWidget::PointInPolygonWidget(QWidget *parent) : QWidget(parent), ui(new Ui::PointInPolygon) { ui->setupUi(this); ui->PolygonTable->setContextMenuPolicy(Qt::ActionsContextMenu); QAction* menu_action_remove_row; menu_action_remove_row = new QAction("Remover", this); ui->PolygonTable->addAction(menu_action_remove_row); QObject::connect(menu_action_remove_row, SIGNAL(triggered()), this, SLOT(remove_row())); //Initialize GPS position_info_ = QGeoPositionInfoSource::createDefaultSource(this); dist_acc_= 0; is_first_distance_ = true; if (position_info_) { position_info_->startUpdates(); connect(position_info_, SIGNAL(positionUpdated(QGeoPositionInfo)), this, SLOT(positionUpdated(QGeoPositionInfo))); } }
void tlistbox::clear() { // Due to the removing from the linked group, don't use // generator_->clear() directly. remove_row(0, 0); }
void test_cursor() { // Create a table named "Table". auto db = grnxx::open_db(""); auto table = db->create_table("Table"); // Insert rows. constexpr size_t NUM_ROWS = 1 << 16; for (size_t i = 0; i < NUM_ROWS; ++i) { table->insert_row(); } // Test a cursor with the default options. auto cursor = table->create_cursor(); grnxx::Array<grnxx::Record> records; assert(cursor->read(0, &records) == 0); assert(records.is_empty()); assert(cursor->read(NUM_ROWS / 2, &records) == (NUM_ROWS / 2)); assert(records.size() == (NUM_ROWS / 2)); assert(cursor->read_all(&records) == (NUM_ROWS / 2)); assert(records.size() == NUM_ROWS); for (size_t i = 0; i < NUM_ROWS; ++i) { grnxx::Int exptected_row_id(i); assert(records[i].row_id.match(exptected_row_id)); assert(records[i].score.raw() == 0.0); } records.clear(); // Test a cursor that scans a table in reverse order. grnxx::CursorOptions cursor_options; cursor_options.order_type = GRNXX_REVERSE_ORDER; cursor = table->create_cursor(cursor_options); assert(cursor->read_all(&records) == NUM_ROWS); assert(records.size() == NUM_ROWS); for (size_t i = 0; i < NUM_ROWS; ++i) { grnxx::Int exptected_row_id(NUM_ROWS - i - 1); assert(records[i].row_id.match(exptected_row_id)); assert(records[i].score.raw() == 0.0); } records.clear(); // Remove 98.4375% rows. std::mt19937 rng; std::vector<grnxx::Int> row_ids; for (size_t i = 0; i < NUM_ROWS; ++i) { grnxx::Int row_id(i); if ((rng() % 64) != 0) { table->remove_row(row_id); } else { row_ids.push_back(row_id); } } // Test a cursor with the default options. cursor = table->create_cursor(); assert(cursor->read_all(&records) == row_ids.size()); for (size_t i = 0; i < row_ids.size(); ++i) { assert(records[i].row_id.match(row_ids[i])); } records.clear(); // Test a cursor that scans a table in reverse order. cursor = table->create_cursor(cursor_options); assert(cursor->read_all(&records) == row_ids.size()); for (size_t i = 0; i < row_ids.size(); ++i) { assert(records[i].row_id.match(row_ids[row_ids.size() - i - 1])); } records.clear(); }
void test_bitmap() { constexpr size_t NUM_ROWS = 1 << 16; // Create a table named "Table". auto db = grnxx::open_db(""); auto table = db->create_table("Table"); // Insert rows. for (size_t i = 0; i < NUM_ROWS; ++i) { grnxx::Int expected_row_id(i); assert(table->insert_row().match(expected_row_id)); } assert(table->num_rows() == NUM_ROWS); assert(table->max_row_id().raw() == (NUM_ROWS - 1)); // Remove all rows. for (size_t i = 0; i < NUM_ROWS; ++i) { grnxx::Int row_id(i); table->remove_row(row_id); } assert(table->num_rows() == 0); assert(table->max_row_id().is_na()); // Insert rows again. for (size_t i = 0; i < NUM_ROWS; ++i) { grnxx::Int exptected_row_id(i); assert(table->insert_row().match(exptected_row_id)); } assert(table->num_rows() == NUM_ROWS); assert(table->max_row_id().raw() == (NUM_ROWS - 1)); // Remove rows with even IDs. for (size_t i = 0; i < NUM_ROWS; i += 2) { grnxx::Int row_id(i); table->remove_row(row_id); } assert(table->num_rows() == (NUM_ROWS / 2)); assert(table->max_row_id().raw() == (NUM_ROWS - 1)); // Insert rows again. for (size_t i = 0; i < NUM_ROWS; i += 2) { grnxx::Int exptected_row_id(i); assert(table->insert_row().match(exptected_row_id)); } assert(table->num_rows() == NUM_ROWS); assert(table->max_row_id().raw() == (NUM_ROWS - 1)); // Remove rows in reverse order. for (size_t i = 0; i < NUM_ROWS; ++i) { grnxx::Int row_id(NUM_ROWS - i - 1); assert(table->max_row_id().match(row_id)); table->remove_row(row_id); } assert(table->max_row_id().is_na()); // Insert rows again. for (size_t i = 0; i < NUM_ROWS; ++i) { grnxx::Int exptected_row_id(i); assert(table->insert_row().match(exptected_row_id)); } assert(table->num_rows() == NUM_ROWS); assert(table->max_row_id().raw() == (NUM_ROWS - 1)); }
void test_contains_and_find_one() { constexpr size_t NUM_ROWS = 1 << 10; // Create a table and insert the first row. auto db = grnxx::open_db(""); auto table = db->create_table("Table"); auto column = table->create_column("Column", T::type()); grnxx::Array<T> values; values.resize(NUM_ROWS); for (size_t i = 0; i < NUM_ROWS; ++i) { generate_random_value(&values[i]); grnxx::Int row_id = table->insert_row(); column->set(row_id, values[i]); } // Test all the values. for (size_t i = 0; i < NUM_ROWS; ++i) { assert(column->contains(values[i])); grnxx::Int row_id = column->find_one(values[i]); assert(!row_id.is_na()); assert(values[i].match(values[row_id.raw()])); } // Test all the values with index if available. try { column->create_index("Index", GRNXX_TREE_INDEX); for (size_t i = 0; i < NUM_ROWS; ++i) { assert(column->contains(values[i])); grnxx::Int row_id = column->find_one(values[i]); assert(!row_id.is_na()); assert(values[i].match(values[row_id.raw()])); } column->remove_index("Index"); } catch (...) { } // Remove N/A values. for (size_t i = 0; i < NUM_ROWS; ++i) { if (values[i].is_na()) { table->remove_row(grnxx::Int(i)); } } // Test all the values. for (size_t i = 0; i < NUM_ROWS; ++i) { if (!values[i].is_na()) { assert(column->contains(values[i])); grnxx::Int row_id = column->find_one(values[i]); assert(!row_id.is_na()); assert(values[i].match(values[row_id.raw()])); } } assert(!column->contains(T::na())); assert(column->find_one(T::na()).is_na()); // Test all the values with index if available. try { column->create_index("Index", GRNXX_TREE_INDEX); for (size_t i = 0; i < NUM_ROWS; ++i) { if (!values[i].is_na()) { assert(column->contains(values[i])); grnxx::Int row_id = column->find_one(values[i]); assert(!row_id.is_na()); assert(values[i].match(values[row_id.raw()])); } } assert(!column->contains(T::na())); assert(column->find_one(T::na()).is_na()); column->remove_index("Index"); } catch (...) { } // Insert a trailing N/A value. table->insert_row_at(grnxx::Int(NUM_ROWS)); assert(column->contains(T::na())); assert(column->find_one(T::na()).match(grnxx::Int(NUM_ROWS))); try { column->create_index("Index", GRNXX_TREE_INDEX); assert(column->contains(T::na())); assert(column->find_one(T::na()).match(grnxx::Int(NUM_ROWS))); column->remove_index("Index"); } catch (...) { } // Remove non-N/A values. for (size_t i = 0; i < NUM_ROWS; ++i) { if (!values[i].is_na()) { table->remove_row(grnxx::Int(i)); } } // Test all the values. for (size_t i = 0; i < NUM_ROWS; ++i) { if (!values[i].is_na()) { assert(!column->contains(values[i])); assert(column->find_one(values[i]).is_na()); } } assert(column->contains(T::na())); assert(column->find_one(T::na()).match(grnxx::Int(NUM_ROWS))); // Test all the values with index if available. try { column->create_index("Index", GRNXX_TREE_INDEX); for (size_t i = 0; i < NUM_ROWS; ++i) { if (!values[i].is_na()) { assert(!column->contains(values[i])); assert(column->find_one(values[i]).is_na()); } } assert(column->contains(T::na())); assert(column->find_one(T::na()).match(grnxx::Int(NUM_ROWS))); column->remove_index("Index"); } catch (...) { } }
void euclid_lsh::clear_row(const string& id) { remove_row(id); if (unlearner_) { unlearner_->remove(id); } }
void mex_epg_grid_add_events (MexEpgGrid *grid, MexChannel *channel, GPtrArray *events) { MexEpgGridPrivate *priv; MexChannelManager *channel_manager; MxFocusManager *focus_manager; GPtrArray *row; gint position; guint i; g_return_if_fail (MEX_IS_EPG_GRID (grid)); g_return_if_fail (MEX_IS_CHANNEL (channel)); g_return_if_fail (events); priv = grid->priv; channel_manager = mex_channel_manager_get_default (); position = mex_channel_manager_get_channel_position (channel_manager, channel); if (G_UNLIKELY (position == -1)) { MEX_WARN (EPG, "Could not find position of channel %s", mex_channel_get_name (channel)); return; } /* no events for this channel */ if (G_UNLIKELY (events->len == 0)) { /* signal that we won't have data for that row */ row_loaded (grid, position); return; } /* we insert tiles in bulk, removing the existing tiles if needed */ row = g_ptr_array_index (priv->rows, position); /* If we already have data for that row, we assume the caller wants to * replace the data. If we don't we signal that a new row is loaded */ if (row) remove_row (grid, position); else row_loaded (grid, position); row = g_ptr_array_new (); g_ptr_array_set_size (row, events->len); /* We are adding events, it's a good time to check if we have a valid * current date */ if (priv->current_date == NULL) priv->current_date = g_date_time_new_now_local (); for (i = 0; i < events->len; i++) { MexEpgEvent *event = g_ptr_array_index (events, i); ClutterActor *tile; tile = mex_epg_tile_new_with_event (event); g_signal_connect (tile, "clicked", G_CALLBACK (on_tile_clicked), grid); clutter_actor_set_parent (tile, CLUTTER_ACTOR (grid)); g_ptr_array_index (row, i) = tile; #if 0 /* Disabled because we don't need to style differently the events that * are occuring now in the current design, might come back though */ if (mex_epg_event_is_date_in_between (event, priv->current_date)) mx_stylable_set_style_class (MX_STYLABLE (tile), "EpgTileNow"); #endif } g_ptr_array_index (priv->rows, position) = row; /* If the EpgGrid had the focus before we had a chance to add events, * it's a good time to push the focus to one of the EpgTile */ /* FIXME: default to the channel we are watching, not row 0 */ if (priv->has_focus_but_no_tile && position == 0 && row->len > 0) { ClutterActor *focused_tile = g_ptr_array_index (row, 0); ClutterActor *stage; stage = clutter_actor_get_stage (focused_tile); focus_manager = mx_focus_manager_get_for_stage (CLUTTER_STAGE (stage)); mx_focus_manager_push_focus (focus_manager, MX_FOCUSABLE (focused_tile)); g_signal_emit (grid, signals[SIGNAL_ROW_SELECTED], 0, 0); priv->has_focus_but_no_tile = FALSE; } /* We have a new row, relayout */ clutter_actor_queue_relayout (CLUTTER_ACTOR (grid)); }
void Matrix::remove_row_col( int row_idx, int column_idx ) { remove_row( row_idx ); remove_column( column_idx ); }
int separa_capacity(int *card,CONSTRAINT **stack) { int k,l,nvar,num,index; double *primal; double *cvar; PROT_LEVEL*pro,*pro0; VARIABLE **xvar; CONSTRAINT*con; char *sleep; double bd[2]; double maxc; if( *card ==MAX_CUTS_ITER) return(0); #ifdef STAMP std::cout << " .. capacity cuts .. "; #endif cvar = (double *)malloc( Rncells * sizeof(double) ); xvar = (VARIABLE **)malloc( Rncells * sizeof(VARIABLE *) ); primal = (double *)malloc( Rncells * sizeof(double) ); if( !cvar || !xvar || !primal ){ std::cout << "There is not enough memory for CAPACITY" << std::endl; CSPexit(EXIT_MEMO); //exit(1); } for(k=0;k<Rncells;k++) primal[k] = columns[k].val; load_network(primal,'C'); num = *card; sleep = (char *)calloc( nprot_level , sizeof(char) ); l = nprot_level; while(l--){ pro = prot_level+l; if( !sleep[l] ){ index = pro->sen->var->index; /////////// free_col(index,bd); if( protection_level(pro->sen->var,pro->sense,&nvar,xvar,cvar,primal,'C') < pro->sense * pro->sen->var->nominal + pro->level-ZERO ){ con = capacity_constraint(nvar,xvar,cvar,pro->sen->var,pro->level); if( con && new_row(con) ){ stack[ num++] = con; if( num==MAX_CUTS_ITER) break; }else remove_row( con ); } /////////// unfree_col(index,bd); k = l; while(k--){ pro0 = prot_level+k; if( pro0->sense * primal[ pro0->sen->var->index ] > pro0->sense * pro0->sen->var->nominal + pro0->level - ZERO ) sleep[k] = 1; } // for introducing an alternative Capacity Cut // a cell must be choosen to be super-suppressed index = -1; maxc = 0.0; for(k=0;k<nvar;k++) if( xvar[k]->val>ZERO && cvar[k]>maxc ){ index = xvar[k]->index; maxc = cvar[k]; } if( index != -1 ){ free_col(index,bd); if( protection_level(pro->sen->var,pro->sense,&nvar,xvar,cvar,NULL,'C') < pro->sense * pro->sen->var->nominal + pro->level-ZERO ){ #ifdef STAMP for(k=0;k<nvar;k++) if( xvar[k]->index==index ){ std::cout << "ERROR: capacity with imposible cell" << std::endl; CSPexit(EXIT_ERROR); //exit(1); } #endif con = capacity_constraint(nvar,xvar,cvar,pro->sen->var,pro->level); if( con && new_row(con) ){ stack[ num++] = con; if( num==MAX_CUTS_ITER) break; }else remove_row( con ); } unfree_col(index,bd); } } } free( sleep ); sleep = NULL; /*PWOF*/ num -= *card; *card += num; unload_network(); free(primal); primal = NULL; /*PWOF*/ free(cvar); cvar = NULL; /*PWOF*/ free(xvar); xvar = NULL; /*PWOF*/ ccapa += num; #ifdef STAMP std::cout << num << std::endl; #endif return( num ); }
int separa_bridge(int *card,CONSTRAINT **stack) { int k,l,nvar,nvar1,nvar2,num; double *primal1,*primal2; double *cvar1,*cvar2,*cvar; VARIABLE *var,*var0; VARIABLE **xvar1,**xvar2,**xvar; CONSTRAINT*con; double minvalue,maxvalue,value; char *sleep; if( *card ==MAX_CUTS_ITER) return(0); #ifdef STAMP std::cout << " .. bridge-less cuts .. "; #endif cvar = (double *)malloc( Rncells * sizeof(double) ); cvar1 = (double *)malloc( Rncells * sizeof(double) ); cvar2 = (double *)malloc( Rncells * sizeof(double) ); xvar1 = (VARIABLE **)malloc( Rncells * sizeof(VARIABLE *) ); xvar2 = (VARIABLE **)malloc( Rncells * sizeof(VARIABLE *) ); xvar = (VARIABLE **)malloc( Rncells * sizeof(VARIABLE *) ); primal1 = (double *)malloc( Rncells * sizeof(double) ); primal2 = (double *)malloc( Rncells * sizeof(double) ); if( !cvar1 || !cvar2 || !xvar || !primal1 || !primal2 ){ std::cout << "There is not enough memory for CAPACITY" << std::endl; CSPexit(EXIT_MEMO); //exit(1); } for(k=0;k<Rncells;k++) primal2[k] = primal1[k] = columns[k].val; load_network(primal1,'C'); num = *card; sleep = (char *)calloc( nsupport , sizeof(char) ); for(k=0;k<nsupport;k++) if( support[k]->sensitive ) sleep[k]=1; l = nsupport; while(l--){ var = support[l]; if( !sleep[l] ){ bounding_1(); maxvalue = protection_level(var,1,&nvar1,xvar1,cvar1,primal1,'C'); minvalue = -protection_level(var,-1,&nvar2,xvar2,cvar2,primal2, 'C'); value = bridge_lhs(nvar1,nvar2,xvar1,xvar2,cvar1,cvar2,&nvar,xvar,cvar); if( maxvalue-minvalue < ZERO || value < var->val+ZERO-MIN_VIOLA ){ con = bridge_constraint(nvar,xvar,var->index); if( con && new_row(con) ){ stack[ num++] = con; if( num==MAX_CUTS_ITER) break; }else remove_row( con ); } k = l; while(k--){ var0 = support[k]; if( fabs(primal2[var0->index] - primal1[var0->index]) > var0->val-MIN_VIOLA+ZERO ) sleep[k] = 1; } } } free( sleep ); sleep = NULL; /*PWOF*/ num -= *card; *card += num; unload_network(); free(primal1); primal1 = NULL; /*PWOF*/ free(primal2); primal2 = NULL; /*PWOF*/ free(xvar); xvar = NULL; /*PWOF*/ free(xvar1); xvar1 = NULL; /*PWOF*/ free(xvar2); xvar2 = NULL; /*PWOF*/ free(cvar); cvar = NULL; /*PWOF*/ free(cvar1); cvar1 = NULL; /*PWOF*/ free(cvar2); cvar2 = NULL; /*PWOF*/ cbrid += num; #ifdef STAMP std::cout << num << std::endl; #endif return( num ); }