void LatexPreviewWindow::SetImage(const wxBitmap& img) { Freeze(); int old_width = 0, old_height = 0; if (m_img.IsOk()) { old_width = m_img.GetWidth(); old_height = m_img.GetHeight(); } wxSize increase(img.GetWidth() - old_width, img.GetHeight() - old_height), frame_size( GetSize() ), new_img_size(img.GetWidth() + 40, img.GetHeight() + 40); m_img = img; // m_mainpanel->Layout(); // m_control_image->SetVirtualSizeHints( new_img_size ); m_control_image->SetInitialSize( new_img_size ); m_control_image->SetMinSize( new_img_size ); m_control_image->SetSize( new_img_size ); m_panel_formula->GetSizer()->Layout(); GetSizer()->SetSizeHints(this); if (m_resize_frame) { if (m_control_image->GetSize().x > m_panel_image->GetSize().x) frame_size.x += m_control_image->GetSize().x - m_panel_image->GetSize().x; frame_size.y += increase.y; } // m_control_image->Refresh(); // m_control_image->Update(); // m_mainpanel->GetSizer()->SetSizeHints(m_mainpanel); SetSize(frame_size); Thaw(); Refresh(); }
/* * fun introot n = * if n = 0 * then 0 * else increase (2 * introot (n div 4), n) */ void introot (mpz_t r, const mpz_t n) { unsigned long int i = 0; unsigned long int size = mpz_sizeinbase (n, 4); mpz_t *stack = malloc (size * sizeof (mpz_t)); mpz_set (r, n); for (i = 1; i <= size; i++) { mpz_init_set (*(stack + size - i), r); mpz_fdiv_q_ui (r, r, 4); } for (i = 0; i < size; i++) { mpz_mul_ui (r, r, 2); increase (r, *(stack + i)); mpz_clear (*(stack + i)); } free (stack); }
void PickerWidget::create() { QVBoxLayout *layout = new QVBoxLayout; layout->setContentsMargins(0,0,0,0); layout->setSpacing(0); m_btnInc = new QPushButton("+"); m_btnInc->setEnabled(false); layout->addWidget(m_btnInc); connect(m_btnInc, SIGNAL(clicked()), this, SLOT(increase())); m_label = new QLabel(); m_label->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter); layout->addWidget(m_label); m_btnDec = new QPushButton("-"); m_btnDec->setEnabled(false); layout->addWidget(m_btnDec); connect(m_btnDec, SIGNAL(clicked()), this, SLOT(decrease())); setLayout(layout); }
void FlagStatus::Item::set(KeyCode key, Flags flags) { temporary_count_ = 0; // ------------------------------------------------------------ if (key != flag_.getKeyCode()) return; // ------------------------------------------------------------ if (flag_ == ModifierFlag::CAPSLOCK) { if (flags.isOn(flag_)) { lock_count_ = 1; } else { lock_count_ = 0; } } else { if (flags.isOn(flag_)) { increase(); } else { decrease(); } } }
V get(K key) { if(prelude_unlikely(!T::valid_key(key))) return 0; size_t hash = T::hash_key(key); size_t index = hash & mask; V entry = table[index]; V tail = entry; while(T::valid_value(entry)) { T::verify_value(entry); if(T::compare_key_value(key, hash, entry)) return entry; tail = entry; entry = T::get_value_next(entry); } if(T::create_value()) { V value = T::create_value(get_allocator(), key, hash); if(tail) T::set_value_next(tail, value); else table[index] = value; T::set_value_next(value, T::invalid_value()); increase(); return value; } else return T::invalid_value(); }
int candy(vector<int>& ratings) { int n = ratings.size(); if(n<2) return 1; vector<int> increase(n,0); for(int i = 1,inc = 1; i<ratings.size();i++) { if(ratings[i]>ratings[i-1]) increase[i] = max(inc++,increase[i]); else inc = 1; } for(int k = ratings.size()-2,inc = 1; k>-1;k--) { if(ratings[k]>ratings[k+1]) increase[k] = max(inc++,increase[k]); else inc = 1; } return accumulate(&increase[0],&increase[0]+n,n); }
TimeUnitBox::TimeUnitBox(QWidget *parent, bool daysonly ) : QWidget( parent ) { QVBoxLayout *vlay = new QVBoxLayout(this); vlay->setMargin(0); vlay->setSpacing(0); UpButton = new QPushButton( QPixmap(up_arrow), "", this ); UpButton->setMaximumWidth( 26 ); UpButton->setMaximumHeight( 13 ); DownButton = new QPushButton( QPixmap(down_arrow), "", this ); DownButton->setMaximumWidth( 26 ); DownButton->setMaximumHeight( 13 ); vlay->addWidget( UpButton ); vlay->addWidget( DownButton ); // setLayout( vlay ); setDaysOnly( daysonly ); connect( UpButton, SIGNAL( clicked() ), this, SLOT( increase() ) ); connect( DownButton, SIGNAL( clicked() ), this, SLOT( decrease() ) ); }
V get(K key) { if(!T::valid_key(key)) return 0; size_t index = T::hash_key(key) & mask; V entry = table[index]; V tail = entry; while(T::valid_value(entry)) { if(T::compare_key_value(key, entry)) return entry; tail = entry; entry = T::get_value_next(entry); } if(T::create_value()) { V value = T::create_value(key, memory_pool); if(tail) T::set_value_next(tail, value); else table[index] = value; T::set_value_next(value, T::invalid_value()); increase(); return value; } else return 0; }
int main(){ insert(5); insert(7); insert(3); insert(8); insert(12); insert(14); insert(118); print_queue(); printf("\nextractMax:\n"); int max = extractMax(); printf("\nThe Max is %d.\n",max); print_queue(); printf("\nincrease, index is [5] and value is [10]:\n"); increase(5,10); print_queue(); printf("\nChange value, index is [5] and value is [10]:\n"); change(5,10); print_queue(); return 0; }
void ArrayList::add(int index, Object *obj) { if(obj == NULL) { return ; } if(index < 0 || index > mSize) { return ; } increase(); obj->retain(); Object** tmp = NULL; int remain = mSize - index; if(remain > 0) { tmp = new Object*[remain]; memset(tmp, 0, sizeof(Object*) * remain); memcpy(tmp, mArray + index, sizeof(Object*) * remain); } mArray[index] = obj; if(remain > 0) { memcpy(mArray + index + 1, tmp, sizeof(Object*) * remain); delete tmp; } mSize++; }
void testVector(int testSize) { printf("\n ==== Test %2d. Generate a random vector\n", testID++); Vector<T> V; for (int i = 0; i < testSize; i++) V.insert(dice((Rank)i+1), dice((T)testSize*3)); //在[0, 3n)中选择n个数,随机插入向量 PRINT(V); permute(V); PRINT(V) printf("\n ==== Test %2d. Lowpass on\n", testID++); PRINT(V); int i = V.size(); while (0 < --i) { V[i-1] += V[i]; V[i-1] >>= 1; } PRINT(V); printf("\n ==== Test %2d. Increase\n", testID++); PRINT(V); increase(V); PRINT(V); printf("\n ==== Test %2d. FIND in\n", testID++); PRINT(V); TestFind<T>(V, testSize); printf("\n ==== Test %2d. Sort degenerate intervals each of size 1 in\n", testID++, 0, V.size()); PRINT(V); for (int i = 0; i < V.size(); i += V.size()/5) { V.sort(i, i); PRINT(V); } //element by element printf("\n ==== Test %2d. Sort 5 intervals each of size %d in\n", testID++, V.size()/5); PRINT(V); for (int i = 0; i < V.size(); i += V.size()/5) { V.sort(i, min(V.size(), i+V.size()/5)); PRINT(V); } //interval by interval printf("\n ==== Test %2d. Sort the entire vector of\n", testID++, 0, V.size()); PRINT(V); V.sort(); PRINT(V); printf("\n ==== Test %2d. FIND in\n", testID++); PRINT(V); TestFind<T>(V, testSize); printf("\n ==== Test %2d. SEARCH in\n", testID++); PRINT(V); TestSearch<T>(V); printf("\n ==== Test %2d. Unsort interval [%d, %d) in\n", testID++, V.size()/4, 3*V.size()/4); PRINT(V); V.unsort(V.size()/4, 3*V.size()/4); PRINT(V); printf("\n ==== Test %2d. Unsort interval [%d, %d) in\n", testID++, 0, V.size()); PRINT(V); V.unsort(); PRINT(V); printf("\n ==== Test %2d. Copy interval [%d, %d) from\n", testID++, V.size()/4, 3*V.size()/4); PRINT(V); Vector<T> U(V, V.size()/4, 3*V.size()/4); PRINT(U); printf("\n ==== Test %2d. Copy from\n", testID++); PRINT(V); Vector<T> W(V); PRINT(W); printf("\n ==== Test %2d. Clone from\n", testID++); PRINT(U); W = U; PRINT(W); printf("\n ==== Test %2d. Remove redundancy in unsorted\n", testID++); PRINT(V); printf("%d node(s) removed\n", V.deduplicate()); PRINT(V); printf("\n ==== Test %2d. Sort interval [%d, %d) in\n", testID++, 0, V.size()); PRINT(V); V.sort(); PRINT(V); printf("\n ==== Test %2d. FIND in V[%d]\n", testID++); PRINT(V); TestFind<T>(V, testSize); printf("\n ==== Test %2d. SEARCH & INSERT in\n", testID++); PRINT(V); TestOrderedInsertion<T>(V, testSize); PRINT(V); printf("\n ==== Test %2d. Remove redundancy in sorted\n", testID++); PRINT(V); printf("%d node(s) removed\n", V.uniquify()); PRINT(V); }
static void increase(PointingButton button) { increase(Buttons(button)); }
BOOST_AUTO_TEST_CASE_TEMPLATE ( test_neighbor_upper_bound, Tp, quad_sets ) { typedef quadrance<typename Tp::container_type, int, quad_diff> metric_type; typedef typename metric_type::distance_type distance_type; typedef neighbor_iterator<typename Tp::container_type, metric_type> neighbor_iterator_type; // Prove that you can find lower bound with N nodes, down to 1 node { Tp fix(100, randomize(-20, 20)); metric_type metric; quad target; while (!fix.container.empty()) { randomize(-22, 22)(target, 0, 0); // Find min and max dist first distance_type min_dist; distance_type max_dist; typename Tp::container_type::iterator it = fix.container.begin(); min_dist = max_dist = metric.distance_to_key(fix.container.rank()(), *it, target); ++it; for (; it != fix.container.end(); ++it) { distance_type tmp = metric.distance_to_key(fix.container.rank()(), *it, target); if (tmp < min_dist) min_dist = tmp; if (tmp > max_dist) max_dist = tmp; } distance_type avg_dist = (min_dist + max_dist) / 2; // use this knowledge to test the upper bound neighbor_iterator_type i = neighbor_upper_bound(fix.container, metric, target, min_dist); BOOST_CHECK(i != neighbor_begin(fix.container, metric, target)); if (i != neighbor_end(fix.container, metric, target)) { BOOST_CHECK_LT(min_dist, distance(i)); } BOOST_CHECK_EQUAL(min_dist, distance(--i)); i = neighbor_upper_bound(fix.container, metric, target, max_dist); BOOST_CHECK(i == neighbor_end(fix.container, metric, target)); i = neighbor_upper_bound(fix.container, metric, target, avg_dist); if (i != neighbor_end(fix.container, metric, target)) { BOOST_CHECK_GT(distance(i), avg_dist); } if (i == neighbor_end(fix.container, metric, target)) { BOOST_CHECK_LE(distance(--i), avg_dist); } fix.container.erase(i); } } // Prove that you can find the upper bound when node and target are same { Tp fix(100, same()); metric_type metric; quad target; same()(target, 0, 100); // All points and targets are the same. while (!fix.container.empty()) { neighbor_iterator_type i = neighbor_upper_bound(fix.container, metric, target, 1); BOOST_CHECK(i == neighbor_end(fix.container, metric, target)); i = neighbor_upper_bound(fix.container, metric, target, 0); BOOST_CHECK(i == neighbor_end(fix.container, metric, target)); fix.container.erase(--i); } } // Prove that you can find the upper bound in an unbalanced tree { Tp fix(100, increase()); metric_type metric; quad target; while (!fix.container.empty()) { randomize(0, 100)(target, 0, 0); // Find min and max dist first distance_type min_dist; distance_type max_dist; typename Tp::container_type::iterator it = fix.container.begin(); min_dist = max_dist = metric.distance_to_key(fix.container.rank()(), *it, target); ++it; for (; it != fix.container.end(); ++it) { distance_type tmp = metric.distance_to_key(fix.container.rank()(), *it, target); if (tmp < min_dist) min_dist = tmp; if (tmp > max_dist) max_dist = tmp; } distance_type avg_dist = (min_dist + max_dist) / 2; // Use this knowledge to test the upper bound neighbor_iterator_type i = neighbor_upper_bound(fix.container, metric, target, min_dist); BOOST_CHECK(i != neighbor_begin(fix.container, metric, target)); if (i != neighbor_end(fix.container, metric, target)) { BOOST_CHECK_LT(min_dist, distance(i)); } BOOST_CHECK_EQUAL(min_dist, distance(--i)); i = neighbor_upper_bound(fix.container, metric, target, max_dist); BOOST_CHECK(i == neighbor_end(fix.container, metric, target)); i = neighbor_upper_bound(fix.container, metric, target, avg_dist); if (i != neighbor_end(fix.container, metric, target)) { BOOST_CHECK_GT(distance(i), avg_dist); } if (i == neighbor_end(fix.container, metric, target)) { BOOST_CHECK_LE(distance(--i), avg_dist); } fix.container.erase(i); } } // Prove that you can find the upper bound in an unbalanced tree { Tp fix(100, decrease()); metric_type metric; quad target; while (!fix.container.empty()) { randomize(0, 100)(target, 0, 0); // Find min and max dist first distance_type min_dist; distance_type max_dist; typename Tp::container_type::iterator it = fix.container.begin(); min_dist = max_dist = metric.distance_to_key(fix.container.rank()(), *it, target); ++it; for (; it != fix.container.end(); ++it) { distance_type tmp = metric.distance_to_key(fix.container.rank()(), *it, target); if (tmp < min_dist) min_dist = tmp; if (tmp > max_dist) max_dist = tmp; } distance_type avg_dist = (min_dist + max_dist) / 2; // Use this knowledge to test the upper bound neighbor_iterator_type i = neighbor_upper_bound(fix.container, metric, target, min_dist); BOOST_CHECK(i != neighbor_begin(fix.container, metric, target)); if (i != neighbor_end(fix.container, metric, target)) { BOOST_CHECK_LT(min_dist, distance(i)); } BOOST_CHECK_EQUAL(min_dist, distance(--i)); i = neighbor_upper_bound(fix.container, metric, target, max_dist); BOOST_CHECK(i == neighbor_end(fix.container, metric, target)); i = neighbor_upper_bound(fix.container, metric, target, avg_dist); if (i != neighbor_end(fix.container, metric, target)) { BOOST_CHECK_GT(distance(i), avg_dist); } if (i == neighbor_end(fix.container, metric, target)) { BOOST_CHECK_LE(distance(--i), avg_dist); } fix.container.erase(i); } } }
BOOST_AUTO_TEST_CASE_TEMPLATE ( test_mapping_minimum, Tp, int2_sets ) { { Tp fix(100, randomize(-20, 20)); // Prove that you can find the min value with N nodes, down to 1 nodes while (!fix.container.empty()) { unsigned int count = 0; int min_value_0 = (*fix.container.begin())[0]; int min_value_1 = (*fix.container.begin())[1]; for(typename Tp::container_type::iterator i = fix.container.begin(); i != fix.container.end(); ++i) { int tmp = (*i)[0]; if (tmp < min_value_0) { min_value_0 = tmp; } tmp = (*i)[1]; if (tmp < min_value_1) { min_value_1 = tmp; } ++count; } BOOST_CHECK_EQUAL(count, fix.container.size()); mapping_iterator<typename Tp::container_type> iter; dimension_type mapping_dim = 0; iter = mapping_begin(fix.container, mapping_dim); BOOST_CHECK_EQUAL((*iter)[mapping_dim], min_value_0); mapping_dim = 1; iter = mapping_begin(fix.container, mapping_dim); BOOST_CHECK_EQUAL((*iter)[mapping_dim], min_value_1); fix.container.erase(iter); } } { // A tree where all elements are the same! Tp fix(100, same()); // Prove that you can find the min value with N nodes, down to 1 nodes while (!fix.container.empty()) { unsigned int count = 0; for(typename Tp::container_type::iterator i = fix.container.begin(); i != fix.container.end(); ++i) { ++count; } BOOST_CHECK_EQUAL(count, fix.container.size()); mapping_iterator<typename Tp::container_type> iter; iter = mapping_begin(fix.container, 0); BOOST_CHECK_EQUAL((*iter)[0], 100); iter = mapping_begin(fix.container, 1); BOOST_CHECK_EQUAL((*iter)[1], 100); fix.container.erase(iter); } } { // test at the limit: a tree with 1 element Tp fix(1, same()); mapping_iterator<const typename Tp::container_type> iter; iter = mapping_cbegin(fix.container, 0); BOOST_CHECK_EQUAL((*iter)[0], 1); // should be (1, 1); BOOST_CHECK_EQUAL((*iter)[1], 1); iter = mapping_cbegin(fix.container, 1); BOOST_CHECK_EQUAL((*iter)[0], 1); // should be (1, 1); BOOST_CHECK_EQUAL((*iter)[1], 1); } { // test at the limit: an unbalanced tree (i.e. insertions in order)! Tp fix(100, decrease()); mapping_iterator<typename Tp::container_type> iter; dimension_type mapping_dim = 0; iter = mapping_begin(fix.container, mapping_dim); BOOST_CHECK_EQUAL((*iter)[0], 1); // should be (1, 1); BOOST_CHECK_EQUAL((*iter)[1], 1); } { // test at the limit: an unbalanced tree (i.e insertions in order)! Tp fix(100, increase()); mapping_iterator<typename Tp::container_type> iter; dimension_type mapping_dim = 1; iter = mapping_begin(fix.container, mapping_dim); BOOST_CHECK_EQUAL((*iter)[0], 0); // should be (0, 0); BOOST_CHECK_EQUAL((*iter)[1], 0); } }
BOOST_AUTO_TEST_CASE_TEMPLATE ( test_mapping_decrement, Tp, int2_maps ) { { // test the invarient of the increment Tp fix(100, randomize(-3, 3)); for (dimension_type mapping_dim = 0; mapping_dim < 2; ++mapping_dim) { std::reverse_iterator <mapping_iterator<typename Tp::container_type> > iter(mapping_end(fix.container, mapping_dim)), end(mapping_begin(fix.container, mapping_dim)); int count = 0; double tmp = iter->first[mapping_dim]; for (; iter != end; ++iter) { BOOST_CHECK_GE(tmp, iter->first[mapping_dim]); tmp = iter->first[mapping_dim]; if (++count > 100) break; } BOOST_CHECK_EQUAL(count, 100); } } { // test at the limit: a tree where all elements are the same Tp fix(100, same()); for (dimension_type mapping_dim = 0; mapping_dim < 2; ++mapping_dim) { std::reverse_iterator <mapping_iterator<typename Tp::container_type> > iter(mapping_end(fix.container, mapping_dim)), end(mapping_begin(fix.container, mapping_dim)); int count = 0; for (; iter != end; ++iter) { BOOST_CHECK_EQUAL(100, iter->first[mapping_dim]); if (++count > 100) break; } BOOST_CHECK_EQUAL(count, 100); } } { // test at the limit: a tree with 2 elements Tp fix(2, same()); for (dimension_type mapping_dim = 0; mapping_dim < 2; ++mapping_dim) { mapping_iterator<const typename Tp::container_type> pre = mapping_cend(fix.container, mapping_dim), post = mapping_cend(fix.container, mapping_dim), begin = mapping_cbegin(fix.container, mapping_dim); BOOST_CHECK(pre != begin); BOOST_CHECK(--pre != post--); BOOST_CHECK(pre == post); BOOST_CHECK(post-- != begin); BOOST_CHECK(--pre == begin); BOOST_CHECK(post == begin); } } { // test at the limit: a right-unbalanced tree (pre-increment) Tp fix(100, increase()); for (dimension_type mapping_dim = 0; mapping_dim < 2; ++mapping_dim) { std::reverse_iterator <mapping_iterator<typename Tp::container_type> > iter(mapping_end(fix.container, mapping_dim)), end(mapping_begin(fix.container, mapping_dim)); int count = 0; double tmp = iter->first[mapping_dim]; for (; iter != end; ++iter) { BOOST_CHECK_GE(tmp, iter->first[mapping_dim]); tmp = iter->first[mapping_dim]; if (++count > 100) break; } BOOST_CHECK_EQUAL(count, 100); } } { // test at the limit: a left-unbalanced tree (post-increment) Tp fix(100, decrease()); for (dimension_type mapping_dim = 0; mapping_dim < 2; ++mapping_dim) { std::reverse_iterator <mapping_iterator<typename Tp::container_type> > iter(mapping_end(fix.container, mapping_dim)), end(mapping_begin(fix.container, mapping_dim)); int count = 0; double tmp = iter->first[mapping_dim]; for (; iter != end; iter++) { BOOST_CHECK_GE(tmp, iter->first[mapping_dim]); tmp = iter->first[mapping_dim]; if (++count > 100) break; } BOOST_CHECK_EQUAL(count, 100); } } }
BigInteger Solver::binaryChoicePointSBTD(Cluster* cluster, int varIndex, Value value) { if (ToulBar2::interrupted) throw TimeOut(); Cost cub = 1; Cost lbgood = 0; BigInteger nbSol = 0, nb = 0; assert(wcsp->unassigned(varIndex)); assert(wcsp->canbe(varIndex, value)); bool dichotomic = (ToulBar2::dichotomicBranching && ToulBar2::dichotomicBranchingSize < wcsp->getDomainSize(varIndex)); Value middle = value; bool increasing = true; if (dichotomic) { middle = (wcsp->getInf(varIndex) + wcsp->getSup(varIndex)) / 2; if (value <= middle) increasing = true; else increasing = false; } try { Store::store(); assert(wcsp->getTreeDec()->getCurrentCluster() == cluster); wcsp->setUb(cub); if (CUT(lbgood, cub)) THROWCONTRADICTION; lastConflictVar = varIndex; if (dichotomic) { if (increasing) decrease(varIndex, middle); else increase(varIndex, middle + 1); } else assign(varIndex, value); lastConflictVar = -1; nb = sharpBTD(cluster); nbSol += nb; } catch (Contradiction) { wcsp->whenContradiction(); } Store::restore(); nbBacktracks++; if (ToulBar2::restart > 0 && nbBacktracks > nbBacktracksLimit) throw NbBacktracksOut(); #ifdef OPENMPI if (ToulBar2::vnsParallel && ((nbBacktracks % 128) == 0) && MPI_interrupted()) throw TimeOut(); #endif try { Store::store(); assert(wcsp->getTreeDec()->getCurrentCluster() == cluster); // assert(wcsp->getLb() == cluster->getLbRec()); wcsp->setUb(cub); if (CUT(lbgood, cub)) THROWCONTRADICTION; if (dichotomic) { if (increasing) increase(varIndex, middle + 1); else decrease(varIndex, middle); } else remove(varIndex, value); nb = sharpBTD(cluster); nbSol += nb; } catch (Contradiction) { wcsp->whenContradiction(); } Store::restore(); return nbSol; }
pair<Cost, Cost> Solver::binaryChoicePoint(Cluster* cluster, Cost lbgood, Cost cub, int varIndex, Value value) { assert(lbgood < cub); if (ToulBar2::interrupted) throw TimeOut(); Cost clb = cub; TreeDecomposition* td = wcsp->getTreeDec(); assert(wcsp->unassigned(varIndex)); assert(wcsp->canbe(varIndex, value)); bool dichotomic = (ToulBar2::dichotomicBranching && ToulBar2::dichotomicBranchingSize < wcsp->getDomainSize(varIndex)); Value middle = value; bool increasing = true; if (dichotomic) { middle = (wcsp->getInf(varIndex) + wcsp->getSup(varIndex)) / 2; if (value <= middle) increasing = true; else increasing = false; } try { Store::store(); assert(td->getCurrentCluster() == cluster); assert(wcsp->getLb() == cluster->getLbRec()); wcsp->setUb(cub); Cost bestlb = lbgood; if (CUT(bestlb, cub)) THROWCONTRADICTION; if (ToulBar2::btdMode >= 2) { Cost rds = td->getLbRecRDS(); bestlb = MAX(bestlb, rds); if (CUT(bestlb, cub)) THROWCONTRADICTION; } lastConflictVar = varIndex; if (dichotomic) { if (increasing) decrease(varIndex, middle); else increase(varIndex, middle + 1); } else assign(varIndex, value); lastConflictVar = -1; bestlb = MAX(bestlb, wcsp->getLb()); pair<Cost, Cost> res = recursiveSolve(cluster, bestlb, cub); clb = MIN(res.first, clb); cub = MIN(res.second, cub); } catch (Contradiction) { wcsp->whenContradiction(); } Store::restore(); nbBacktracks++; if (ToulBar2::restart > 0 && nbBacktracks > nbBacktracksLimit) throw NbBacktracksOut(); #ifdef OPENMPI if (ToulBar2::vnsParallel && ((nbBacktracks % 128) == 0) && MPI_interrupted()) throw TimeOut(); #endif cluster->nbBacktracks++; try { Store::store(); assert(wcsp->getTreeDec()->getCurrentCluster() == cluster); assert(wcsp->getLb() == cluster->getLbRec()); wcsp->setUb(cub); Cost bestlb = lbgood; if (CUT(bestlb, cub)) THROWCONTRADICTION; if (ToulBar2::btdMode >= 2) { Cost rds = td->getLbRecRDS(); bestlb = MAX(bestlb, rds); if (CUT(bestlb, cub)) THROWCONTRADICTION; } if (dichotomic) { if (increasing) increase(varIndex, middle + 1, cluster->nbBacktracks >= cluster->hbfsLimit || nbBacktracks >= cluster->hbfsGlobalLimit); else decrease(varIndex, middle, cluster->nbBacktracks >= cluster->hbfsLimit || nbBacktracks >= cluster->hbfsGlobalLimit); } else remove(varIndex, value, cluster->nbBacktracks >= cluster->hbfsLimit || nbBacktracks >= cluster->hbfsGlobalLimit); bestlb = MAX(bestlb, wcsp->getLb()); if (!ToulBar2::hbfs && cluster == td->getRoot() && initialDepth + 1 == Store::getDepth()) { initialDepth++; showGap(bestlb, cub); }; if (cluster->nbBacktracks >= cluster->hbfsLimit || nbBacktracks >= cluster->hbfsGlobalLimit) { addOpenNode(*(cluster->cp), *(cluster->open), bestlb, cluster->getCurrentDelta()); } else { pair<Cost, Cost> res = recursiveSolve(cluster, bestlb, cub); clb = MIN(res.first, clb); cub = MIN(res.second, cub); } } catch (Contradiction) { wcsp->whenContradiction(); } Store::restore(); assert(lbgood <= clb); assert(clb <= cub); return make_pair(clb, cub); }
BOOST_AUTO_TEST_CASE_TEMPLATE ( test_neighbor_decrement, Tp, int2_maps ) { // Prove that you can iterate N nodes, down to 1 node { Tp fix(100, randomize(-20, 20)); int2 target; typedef typename neighbor_iterator<typename Tp::container_type> ::distance_type distance_type; while (!fix.container.empty()) { randomize(-22, 22)(target, 0, 0); size_t countdown = fix.container.size(); std::reverse_iterator<neighbor_iterator<typename Tp::container_type> > iter(--neighbor_end(fix.container, target)), end(neighbor_begin(fix.container, target)); distance_type max_dist = distance(iter.base()); for(; --countdown != 0 && iter != end; ++iter) { distance_type tmp = distance(iter.base()); BOOST_CHECK_LE(tmp, max_dist); max_dist = tmp; } BOOST_CHECK_EQUAL(countdown, 0u); BOOST_CHECK(iter == end); fix.container.erase(fix.container.begin()); } } // Prove that you can iterate a very unbalanced tree { Tp fix(40, increase()); int2 target; typedef typename neighbor_iterator<typename Tp::container_type> ::distance_type distance_type; while (!fix.container.empty()) { randomize(0, 40)(target, 0, 0); size_t countdown = fix.container.size(); std::reverse_iterator<neighbor_iterator<typename Tp::container_type> > iter(--neighbor_end(fix.container, target)), end(neighbor_begin(fix.container, target)); distance_type max_dist = distance(iter.base()); for(; --countdown != 0 && iter != end; ++iter) { distance_type tmp = distance(iter.base()); BOOST_CHECK_LE(tmp, max_dist); max_dist = tmp; } BOOST_CHECK_EQUAL(countdown, 0u); BOOST_CHECK(iter == end); fix.container.erase(fix.container.begin()); } } // Prove that you can iterate an opposite unbalanced tree { Tp fix(40, decrease()); int2 target; typedef typename neighbor_iterator<typename Tp::container_type> ::distance_type distance_type; while (!fix.container.empty()) { randomize(0, 40)(target, 0, 0); size_t countdown = fix.container.size(); std::reverse_iterator<neighbor_iterator<typename Tp::container_type> > iter(--neighbor_end(fix.container, target)), end(neighbor_begin(fix.container, target)); distance_type max_dist = distance(iter.base()); for(; --countdown != 0 && iter != end; ++iter) { distance_type tmp = distance(iter.base()); BOOST_CHECK_LE(tmp, max_dist); max_dist = tmp; } BOOST_CHECK_EQUAL(countdown, 0u); BOOST_CHECK(iter == end); fix.container.erase(fix.container.begin()); } } // Prove that you can iterate equivalent nodes { int2 target; same()(target, 0, 100); Tp fix(100, same()); std::reverse_iterator<neighbor_iterator<typename Tp::container_type> > iter(neighbor_end(fix.container, target)), end(neighbor_begin(fix.container, target)); size_t count = 1; ++iter; for(; iter != end && count < fix.container.size(); ++iter, ++count) { BOOST_CHECK_CLOSE(distance(iter.base()), 0.0, 0.000000001); } BOOST_CHECK(iter == end); BOOST_CHECK_EQUAL(count, fix.container.size()); } }
void menu_keys () { static int enter; int ent = 0; static int esc; #ifdef MOUSE static int button; int but = 0; #endif if (maxim[1].max != maxlevel && !client) main_menu (); changed = 0; if (IsPressedLeft ()) { int i; for (i = 0; i < nnumbers; i++) if (maxim[i].line == selected) decrease (i); } if (IsPressedRight ()) { int i; for (i = 0; i < nnumbers; i++) if (maxim[i].line == selected) increase (i); } #ifdef MOUSE but = nomouse ? 0 : MouseButtons (); if (but) { int i; for (i = 0; i < nnumbers; i++) { if (MouseX () > maxim[i].x && MouseX () < maxim[i].x + 8 && MouseY () > maxim[i].y && MouseY () < maxim[i].y + 8) increase (i); if (MouseX () > minim[i].x && MouseX () < minim[i].x + 8 && MouseY () > minim[i].y && MouseY () < minim[i].y + 8) decrease (i); } } if (!but && button) { int i; i = (MouseY () - MAPHEIGHT / 2 - 20 + 5 * nmenu) / 10; if (i >= 0 && i < nmenu) { selected = i; #ifdef SOUND if (ssound) play_sound (S_CREATOR2); #endif menu[selected].func (); button = 0; return; } } button = but; #endif if (IsPressedEsc ()) { if(!esc) { if (client || nnumbers == 2) quit (); to_main_menu (); } esc=1; } else esc=0; if (IsPressedUp () && !mtime && selected > 0) selected--, fit_selector (); if (IsPressedDown () && !mtime && selected < nmenu - 1) selected++, fit_selector (); if (IsPressedEnter () && !mtime) ent = 1; if (!ent && enter) { #ifdef SOUND if (ssound) play_sound (S_CREATOR2); #endif menu[selected].func (); } enter = ent; if (!changed) inctime = 7, waittime = 0; }
void replace(size_type i, const T& value) { increase(i, value - elems_[i]); }
BOOST_AUTO_TEST_CASE_TEMPLATE ( test_mapping_maximum, Tp, int2_sets ) { { Tp fix(100, randomize(-20, 20)); // Prove that you can find the max value with N nodes, down to 1 nodes while (!fix.container.empty()) { unsigned int count = 0; int max_value_0 = (*fix.container.begin())[0]; int max_value_1 = (*fix.container.begin())[1]; for(typename Tp::container_type::iterator i = fix.container.begin(); i != fix.container.end(); ++i) { int tmp = (*i)[0]; if (tmp > max_value_0) { max_value_0 = tmp; } tmp = (*i)[1]; if (tmp > max_value_1) { max_value_1 = tmp; } ++count; } BOOST_CHECK_EQUAL(count, fix.container.size()); mapping_iterator<typename Tp::container_type> iter; iter = mapping_end(fix.container, 0); --iter; // When at the end, this call the 'maximum' function BOOST_REQUIRE_EQUAL((*iter)[0], max_value_0); iter = mapping_end(fix.container, 1); --iter; BOOST_REQUIRE_EQUAL((*iter)[1], max_value_1); fix.container.erase(iter); } } { // A tree where all elements are the same! Tp fix(100, same()); // Prove that you can find the max value with N nodes, down to 1 nodes while (!fix.container.empty()) { unsigned int count = 0; for(typename Tp::container_type::iterator i = fix.container.begin(); i != fix.container.end(); ++i) { ++count; } BOOST_CHECK_EQUAL(count, fix.container.size()); mapping_iterator<typename Tp::container_type> iter; iter = mapping_end(fix.container, 0); --iter; BOOST_CHECK_EQUAL((*iter)[0], 100); iter = mapping_end(fix.container, 1); --iter; BOOST_CHECK_EQUAL((*iter)[1], 100); fix.container.erase(iter); } } { // test at the limit: a tree with 1 element Tp fix(1, same()); mapping_iterator<const typename Tp::container_type> iter; iter = mapping_cend(fix.container, 0); --iter; BOOST_CHECK_EQUAL((*iter)[0], 1); // should be (1, 1); BOOST_CHECK_EQUAL((*iter)[1], 1); iter = mapping_cend(fix.container, 1); --iter; BOOST_CHECK_EQUAL((*iter)[0], 1); // should be (1, 1); BOOST_CHECK_EQUAL((*iter)[1], 1); } { // test at the limit: an unbalanced tree! Tp fix(100, decrease()); mapping_iterator<typename Tp::container_type> iter; iter = mapping_end(fix.container, 0); --iter; BOOST_CHECK_EQUAL((*iter)[0], 100); // should be (100, 100); BOOST_CHECK_EQUAL((*iter)[1], 100); } { // test at the limit: an unbalanced tree! Tp fix(100, increase()); mapping_iterator<typename Tp::container_type> iter; iter = mapping_end(fix.container, 1); --iter; BOOST_CHECK_EQUAL((*iter)[0], 99); // should be (99, 99); BOOST_CHECK_EQUAL((*iter)[1], 99); } }
void ChronoClass::increaseSystem(){ if(systemTime != GetTickCount()){ systemTime = GetTickCount(); increase(); } }
BOOST_AUTO_TEST_CASE_TEMPLATE ( test_mapping_upper_bound, Tp, quad_maps ) { { // find the smallest element that is greater than key Tp fix(100, randomize(-2, 2)); quad lower (-3, -3, -3, -3); quad in (-1, -1, -1, -1); quad upper (1, 1, 1, 1); for (dimension_type mapping_dim = 0; mapping_dim < 4; ++mapping_dim) { mapping_iterator<typename Tp::container_type> iter (mapping_upper_bound(fix.container, mapping_dim, in)); BOOST_CHECK(iter == mapping_end(fix.container, mapping_dim) || quad_less()(mapping_dim, in, iter->first)); BOOST_CHECK(iter == mapping_begin(fix.container, mapping_dim) || !quad_less()(mapping_dim, (--iter)->first, in)); iter = mapping_upper_bound(fix.container, mapping_dim, lower); BOOST_CHECK(iter == mapping_begin(fix.container, mapping_dim)); iter = mapping_upper_bound(fix.container, mapping_dim, upper); BOOST_CHECK(iter == mapping_end(fix.container, mapping_dim)); } } { // same test with a tree filled with similar values Tp fix(100, same()); quad lower (99, 99, 99, 99); quad in (100, 100, 100, 100); quad upper (101, 101, 101, 101); for (dimension_type mapping_dim = 0; mapping_dim < 4; ++mapping_dim) { mapping_iterator<typename Tp::container_type> iter (mapping_upper_bound(fix.container, mapping_dim, lower)); BOOST_CHECK(iter == mapping_begin(fix.container, mapping_dim)); iter = mapping_upper_bound(fix.container, mapping_dim, in); BOOST_CHECK(iter == mapping_end(fix.container, mapping_dim)); iter = mapping_upper_bound(fix.container, mapping_dim, upper); BOOST_CHECK(iter == mapping_end(fix.container, mapping_dim)); } } { // test at the limit: tree with 1 value Tp fix(1, same()); quad lower (0, 0, 0, 0); quad in (1, 1, 1, 1); quad upper (2, 2, 2, 2); for (dimension_type mapping_dim = 0; mapping_dim < 4; ++mapping_dim) { mapping_iterator<const typename Tp::container_type> iter (mapping_cupper_bound(fix.container, mapping_dim, lower)); BOOST_CHECK(iter == mapping_cbegin(fix.container, mapping_dim)); iter = mapping_cupper_bound(fix.container, mapping_dim, in); BOOST_CHECK(iter == mapping_cend(fix.container, mapping_dim)); iter = mapping_cupper_bound(fix.container, mapping_dim, upper); BOOST_CHECK(iter == mapping_cend(fix.container, mapping_dim)); } } { // test at the limit: tree filled with decreasing values Tp fix(100, decrease()); // first (100, 100, 100, 100), last (1, 1, 1, 1) quad lower(0, 0, 0, 0); quad in (99, 99, 99, 99); quad upper(100, 100, 100, 100); for (dimension_type mapping_dim = 0; mapping_dim < 4; ++mapping_dim) { mapping_iterator<typename Tp::container_type> iter (mapping_upper_bound(fix.container, mapping_dim, lower)); BOOST_CHECK(iter == mapping_begin(fix.container, mapping_dim)); iter = mapping_upper_bound(fix.container, mapping_dim, in); BOOST_CHECK(iter != mapping_end(fix.container, mapping_dim) && ++iter == mapping_end(fix.container, mapping_dim)); iter = mapping_upper_bound(fix.container, mapping_dim, upper); BOOST_CHECK(iter == mapping_end(fix.container, mapping_dim)); } } { // test at the limit: tree filled with increasing values Tp fix(100, increase()); // first (0, 0, 0, 0), last (99, 99, 99, 99) quad lower(-1, -1, -1, -1); quad in(98, 98, 98, 98); quad upper (99, 99, 99, 99); for (dimension_type mapping_dim = 0; mapping_dim < 4; ++mapping_dim) { mapping_iterator<typename Tp::container_type> iter (mapping_upper_bound(fix.container, mapping_dim, lower)); BOOST_CHECK(iter == mapping_begin(fix.container, mapping_dim)); iter = mapping_upper_bound(fix.container, mapping_dim, in); BOOST_CHECK(iter != mapping_end(fix.container, mapping_dim) && ++iter == mapping_end(fix.container, mapping_dim)); iter = mapping_upper_bound(fix.container, mapping_dim, upper); BOOST_CHECK(iter == mapping_end(fix.container, mapping_dim)); } } }
void ChronoClass::increaseSleep(){ increase(); Sleep(1); }
void remove(Value newValue, bool isDecision = false) {if (newValue==inf) increase(newValue+1, isDecision); else if (newValue==sup) decrease(newValue-1, isDecision);}
void update(int index, T new_value) { increase(index, new_value - readSingle(index)); }
void increase(ModifierFlag flag) { increase(Flags(flag)); }
void vsx_widget_2d_pager::event_mouse_down(vsx_widget_distance distance,vsx_widget_coords coords,int button) { distance.center.x > 0.0f ? increase() : decrease(); }
void IceExceptionCounter::increase(Ice::Exception& e) { LOG_INFO("[" << fileName_ << "]-IceExceptionCounter::increase with " << e.what()); increase(); }
NEKey NE_DLL &NEKey::operator++(int) { increase(); return *this; }