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