size_t BufferArray::append(const void * src, size_t len)
{
const size_t ret(len);
const char * c_src(static_cast<const char *>(src));
// First, try to copy into the last block
if (len && ! mBlocks.empty())
{
Block & last(*mBlocks.back());
if (last.mUsed < last.mAlloced)
{
// Some will fit...
const size_t copy_len((std::min)(len, (last.mAlloced - last.mUsed)));
memcpy(&last.mData[last.mUsed], c_src, copy_len);
last.mUsed += copy_len;
llassert_always(last.mUsed <= last.mAlloced);
mLen += copy_len;
c_src += copy_len;
len -= copy_len;
}
}
// Then get new blocks as needed
while (len)
{
const size_t copy_len((std::min)(len, BLOCK_ALLOC_SIZE));
if (mBlocks.size() >= mBlocks.capacity())
{
mBlocks.reserve(mBlocks.size() + 5);
}
Block * block = Block::alloc(BLOCK_ALLOC_SIZE);
memcpy(block->mData, c_src, copy_len);
block->mUsed = copy_len;
llassert_always(block->mUsed <= block->mAlloced);
mBlocks.push_back(block);
mLen += copy_len;
c_src += copy_len;
len -= copy_len;
}
return ret;
}
void XTS_Decryption::finish(secure_vector<uint8_t>& buffer, size_t offset)
{
BOTAN_ASSERT(buffer.size() >= offset, "Offset is sane");
const size_t sz = buffer.size() - offset;
uint8_t* buf = buffer.data() + offset;
BOTAN_ASSERT(sz >= minimum_final_size(), "Have sufficient final input in XTS decrypt");
const size_t BS = cipher().block_size();
if(sz % BS == 0)
{
update(buffer, offset);
}
else
{
// steal ciphertext
const size_t full_blocks = ((sz / BS) - 1) * BS;
const size_t final_bytes = sz - full_blocks;
BOTAN_ASSERT(final_bytes > BS && final_bytes < 2*BS, "Left over size in expected range");
secure_vector<uint8_t> last(buf + full_blocks, buf + full_blocks + final_bytes);
buffer.resize(full_blocks + offset);
update(buffer, offset);
xor_buf(last, tweak() + BS, BS);
cipher().decrypt(last);
xor_buf(last, tweak() + BS, BS);
for(size_t i = 0; i != final_bytes - BS; ++i)
{
last[i] ^= last[i + BS];
last[i + BS] ^= last[i];
last[i] ^= last[i + BS];
}
xor_buf(last, tweak(), BS);
cipher().decrypt(last);
xor_buf(last, tweak(), BS);
buffer += last;
}
}
void CTS_Decryption::finish(secure_vector<uint8_t>& buffer, size_t offset)
{
BOTAN_ASSERT(buffer.size() >= offset, "Offset is sane");
const size_t sz = buffer.size() - offset;
uint8_t* buf = buffer.data() + offset;
const size_t BS = cipher().block_size();
if(sz < BS + 1)
throw Encoding_Error(name() + ": insufficient data to decrypt");
if(sz % BS == 0)
{
// swap last two blocks
for(size_t i = 0; i != BS; ++i)
std::swap(buffer[buffer.size()-BS+i], buffer[buffer.size()-2*BS+i]);
update(buffer, offset);
}
else
{
const size_t full_blocks = ((sz / BS) - 1) * BS;
const size_t final_bytes = sz - full_blocks;
BOTAN_ASSERT(final_bytes > BS && final_bytes < 2*BS, "Left over size in expected range");
secure_vector<uint8_t> last(buf + full_blocks, buf + full_blocks + final_bytes);
buffer.resize(full_blocks + offset);
update(buffer, offset);
cipher().decrypt(last.data());
xor_buf(last.data(), &last[BS], final_bytes - BS);
for(size_t i = 0; i != final_bytes - BS; ++i)
std::swap(last[i], last[i + BS]);
cipher().decrypt(last.data());
xor_buf(last.data(), state_ptr(), BS);
buffer += last;
}
}
std::string IntToUTF8String(int convertMe){
// We only care about plane 1 right now,
// but know that we have other options (0x10FFFF)
// Technically UTF-8 is "limited" to 4 bytes, so it's not
// Like it matters much anyways these days
if(convertMe == 0)
return " ";
if( (convertMe <= 0x7F) && (convertMe > 0x00) ){
std::string out(".");
std::bitset<8> x(convertMe);
unsigned long l = x.to_ulong();
unsigned char c = static_cast<unsigned char>(l);
out[0] = c;
return out;
} else if ( (convertMe >= 0x80) && (convertMe <= 0x07FF) ) {
std::string out("..");
int firstShift = (convertMe >> 0x06) ^ 0xC0;
int secondShift = ((convertMe ^ 0xFFC0) | 0x80) & ~0x40;
std::bitset<8> first(firstShift);
std::bitset<8> last(secondShift);
unsigned long l = first.to_ulong();
unsigned char c = static_cast<unsigned char>(l);
out[0] = c;
unsigned long ltwo = last.to_ulong();
unsigned char ctwo = static_cast<unsigned char>(ltwo);
out[1] = ctwo;
return out;
} else if( (convertMe >= 0x0800) && (convertMe <= 0xFFFF) ){
void DiscreteTrajectory<Frame>::Append(
Instant const& time,
DegreesOfFreedom<Frame> const& degrees_of_freedom) {
CHECK(this->is_root() || time > this->Fork().time())
<< "Append at " << time << " which is before fork time "
<< this->Fork().time();
if (!timeline_.empty() && timeline_.cbegin()->first == time) {
LOG(WARNING) << "Append at existing time " << time
<< ", time range = [" << this->Begin().time() << ", "
<< last().time() << "]";
return;
}
auto it = timeline_.emplace_hint(timeline_.end(),
time,
degrees_of_freedom);
// Decrementing |end()| is much faster than incrementing |it|. Don't ask.
CHECK(--timeline_.end() == it) << "Append out of order";
}
/*
* The algorithm to break a multiple open or closed subpaths is:
* Subpath is closed
* - open behind the last point in the subpath
* - go on like as described in Not closed
* Not closed
* - break from the back of the subpath
*/
KoPathBreakAtPointCommand::KoPathBreakAtPointCommand(const QList<KoPathPointData> & pointDataList, KUndo2Command *parent)
: KUndo2Command(parent)
, m_deletePoints(true)
{
QList<KoPathPointData> sortedPointDataList(pointDataList);
qSort(sortedPointDataList);
setText(i18nc("(qtundo-format)", "Break subpath at points"));
QList<KoPathPointData>::const_iterator it(sortedPointDataList.constBegin());
for (; it != sortedPointDataList.constEnd(); ++it) {
KoPathShape * pathShape = it->pathShape;
KoPathPoint * point = pathShape->pointByIndex(it->pointIndex);
if(! point)
continue;
// check if subpath is closed and the point is start or end point of the subpath
if(! pathShape->isClosedSubpath(it->pointIndex.first)) {
if(it->pointIndex.second == 0
|| it->pointIndex.second == pathShape->subpathPointCount(it->pointIndex.first)) {
continue;
}
}
m_pointDataList.append(*it);
m_points.push_back(new KoPathPoint(*point));
m_closedIndex.push_back(KoPathPointIndex(-1, 0));
}
KoPathPointData last(0, KoPathPointIndex(-1, -1));
for (int i = m_pointDataList.size() - 1; i >= 0; --i) {
const KoPathPointData ¤t = m_pointDataList.at(i);
if (last.pathShape != current.pathShape || last.pointIndex.first != current.pointIndex.first) {
last = current;
if (current.pathShape->isClosedSubpath(current.pointIndex.first)) {
// the break will happen before the inserted point so we have to increment by 1
m_closedIndex[i] = current.pointIndex;
++m_closedIndex[i].second;
}
}
}
}
void KoPathBreakAtPointCommand::redo()
{
KUndo2Command::redo();
KoPathPointData last(0, KoPathPointIndex(-1, -1));
// offset, needed when path was opened
int offset = 0;
for (int i = m_pointDataList.size() - 1; i >= 0; --i) {
const KoPathPointData & pd = m_pointDataList.at(i);
KoPathShape * pathShape = pd.pathShape;
KoPathPointIndex pointIndex = pd.pointIndex;
if (last.pathShape != pathShape || last.pointIndex.first != pointIndex.first) {
offset = 0;
}
pointIndex.second = pointIndex.second + offset + 1;
pathShape->insertPoint(m_points[i], pointIndex);
if (m_closedIndex.at(i).first != -1) {
m_closedIndex[i] = pathShape->openSubpath(m_closedIndex.at(i));
offset = m_closedIndex.at(i).second;
} else {
KoPathPointIndex breakIndex = pd.pointIndex;
breakIndex.second += offset;
pathShape->breakAfter(breakIndex);
m_closedIndex[i].second = offset;
}
if (last.pathShape != pathShape) {
if (last.pathShape) {
last.pathShape->update();
}
last = pd;
}
}
if (last.pathShape) {
last.pathShape->update();
}
m_deletePoints = false;
}
std::ostream& operator << (std::ostream& s, const adobe::extents_t::slice_t& x)
{
adobe::guide_set_t::const_iterator first(x.guide_set_m.begin());
adobe::guide_set_t::const_iterator last(x.guide_set_m.end());
s << adobe::begin_bag("[0]")
<< adobe::begin_sequence
<< adobe::format(adobe::static_name_t("length"))
<< adobe::format(x.length_m)
<< adobe::end_sequence
<< adobe::begin_sequence
<< adobe::format(adobe::static_name_t("outset"))
<< adobe::begin_sequence
<< adobe::format(x.outset_m.first)
<< adobe::format(x.outset_m.second)
<< adobe::end_sequence
<< adobe::end_sequence
<< adobe::begin_sequence
<< adobe::format(adobe::static_name_t("frame"))
<< adobe::begin_sequence
<< adobe::format(x.frame_m.first)
<< adobe::format(x.frame_m.second)
<< adobe::end_sequence
<< adobe::end_sequence
<< adobe::begin_sequence
<< adobe::format(adobe::static_name_t("inset"))
<< adobe::begin_sequence
<< adobe::format(x.inset_m.first)
<< adobe::format(x.inset_m.second)
<< adobe::end_sequence
<< adobe::end_sequence
<< adobe::begin_sequence
<< adobe::format(adobe::static_name_t("poi_set"))
<< adobe::begin_sequence;
for (; first != last; ++first)
s << adobe::format(*first);
s << adobe::end_sequence
<< adobe::end_sequence
<< adobe::end_bag;
return s;
}
float interpKey(const Nif::FloatKeyList::VecType &keys, float time, float def=0.f) const
{
if (keys.size() == 0)
return def;
if(time <= keys.front().mTime)
return keys.front().mValue;
Nif::FloatKeyList::VecType::const_iterator iter(keys.begin()+1);
for(;iter != keys.end();iter++)
{
if(iter->mTime < time)
continue;
Nif::FloatKeyList::VecType::const_iterator last(iter-1);
float a = (time-last->mTime) / (iter->mTime-last->mTime);
return last->mValue + ((iter->mValue - last->mValue)*a);
}
return keys.back().mValue;
}
real TimesExpression::execute(Environment &env) const {
SaveOldValue<real> it (env.iteration_value());
SaveOldValue<real> last(env.last_value ());
try {
for (real n = exec<0>(env), i = 0; i < n; i += 1.0) {
it = i;
last = exec<1>(env);
}
return exec<2>(env);
}
catch (BreakException &e) {
if (e.end()) {
return e.getValue();
} else {
throw;
}
}
}
void tab_group_t::measure(extents_t& result)
{
assert(control_m);
// REVISIT (fbrereto) : A lot of static metrics values added here
boost::shared_ptr<GG::StyleFactory> style = GG::GUI::GetGUI()->GetStyleFactory();
for (tab_set_t::iterator first(items_m.begin()), last(items_m.end());
first != last;
++first) {
GG::X text_width = style->DefaultFont()->TextExtent(first->name_m).x;
result.width() += Value(text_width) + 18;
}
result.height() = Value(control_m->MinUsableSize().y);
result.vertical().frame_m.first = result.height() + 7;
result.height() = 5;
}
void rai::landing::distribute_one ()
{
auto now (rai::seconds_since_epoch ());
rai::block_hash last (1);
while (!last.is_zero () && store.last + distribution_interval.count () < now)
{
auto amount (distribution_amount ((store.last - store.start) >> interval_exponent));
last = wallet->send_sync (store.source, store.destination, amount);
if (!last.is_zero ())
{
BOOST_LOG (node.log) << boost::str (boost::format ("Successfully distributed %1% in block %2%") % amount % last.to_string ());
store.last += distribution_interval.count ();
write_store ();
}
else
{
BOOST_LOG (node.log) << "Error while sending distribution";
}
}
}
void TileNode::queryTile(const SpatialDimension* hashing, const Query& query, Response& response, ulong level) const {
const ulong d = level % hashing->key().size();
if (query.evalTile(d)) {
if (query.getTile(d) == _pivot.value() || (last() && util::intersects(_pivot.value(), query.getTile(d)))) {
aggregateTile(hashing, query, response, level);
} else if (_pivot.value().z < query.zoom) {
if (_container[0] != nullptr) _container[0]->queryTile(hashing, query, response, level + 1);
if (_container[1] != nullptr) _container[1]->queryTile(hashing, query, response, level + 1);
if (_container[2] != nullptr) _container[2]->queryTile(hashing, query, response, level + 1);
if (_container[3] != nullptr) _container[3]->queryTile(hashing, query, response, level + 1);
}
} else {
if (_container[0] != nullptr) _container[0]->queryTile(hashing, query, response, level + 1);
if (_container[1] != nullptr) _container[1]->queryTile(hashing, query, response, level + 1);
if (_container[2] != nullptr) _container[2]->queryTile(hashing, query, response, level + 1);
if (_container[3] != nullptr) _container[3]->queryTile(hashing, query, response, level + 1);
}
}
bool tBlob::ConnectedWithImageBorder( uint32_xy size_ )const {
if( this->streak_count() == 0 ) {
return false;
}
auto iStreakStart = _streaks.begin();
auto iStreakEnd = _streaks.end();
auto bottom = size_.x() - 1 ;
auto right = size_.y() - 1;
uint32_t top = 0;
uint32_t left = 0;
while( iStreakStart != iStreakEnd ) {
auto x = iStreakStart->x();
auto y = iStreakStart->y();
auto last_ = iStreakStart->last();
if(
// top
y == top
||
// bottom
y == bottom
||
// left
x == left
||
// right
last_ == right
) {
return true;
}
++iStreakStart;
}
return false;
}
void
ReliableSession::expire_naks()
{
if (this->nak_requests_.empty()) return; // nothing to expire
ACE_Time_Value deadline(ACE_OS::gettimeofday());
deadline -= this->link_->config()->nak_timeout_;
NakRequestMap::iterator first(this->nak_requests_.begin());
NakRequestMap::iterator last(this->nak_requests_.upper_bound(deadline));
if (first == last) return; // nothing to expire
// Skip unrecoverable datagrams to
// re-establish a baseline to detect future reception gaps.
SequenceNumber lastSeq = (last == this->nak_requests_.end())
? this->nak_requests_.rbegin()->second
: last->second;
std::vector<SequenceRange> dropped;
if (this->nak_sequence_.insert(SequenceRange(this->nak_sequence_.low(),
lastSeq), dropped)) {
for (size_t i = 0; i < dropped.size(); ++i) {
this->reassembly_.data_unavailable(dropped[i]);
}
ACE_ERROR((LM_WARNING,
ACE_TEXT("(%P|%t) WARNING: ")
ACE_TEXT("ReliableSession::expire_naks: ")
ACE_TEXT("timed out waiting on remote peer %#08x%08x to send missing samples: %q - %q!\n"),
(unsigned int)(this->remote_peer_ >> 32),
(unsigned int) this->remote_peer_,
this->nak_sequence_.low().getValue(),
lastSeq.getValue()));
}
// Clear expired repair requests:
this->nak_requests_.erase(first, last);
deliver_held_data();
}
uint32 CBackgroundSound::getDuration()
{
if (_DurationValid)
return _Duration;
vector<sint32> durations;
CAudioMixerUser *mixer = CAudioMixerUser::instance();
std::vector<TSoundInfo>::const_iterator first(_Sounds.begin()), last(_Sounds.end());
for (; first != last; ++first)
{
CSound *sound = mixer->getSoundId(first->SoundName);
if (sound != NULL)
durations.push_back(sound->getDuration());
}
if (durations.empty())
return 0;
_Duration = *(std::max_element(durations.begin(), durations.end()));
_DurationValid = true;
return _Duration;
}
void WMALuminance::onLast() {
std::list<double> queue;
for (InputImageInfo in : inputs) {
queue.push_back(in.luminance);
if (queue.size() > count)
queue.pop_front();
double sum = 0;
double sumWeight = 0;
size_t i = 1;
for (double d : queue) {
double w = (double) i / (double) queue.size();
sum += w * d;
sumWeight += w;
i++;
}
in.luminanceChange = (sum / sumWeight) - in.luminance;
emit input(in);
}
emit last();
}
vector<vector<int>> generate(int numRows)
{
vector<vector<int>> ans;
if(numRows<=0)
{
return ans;
}
vector<int> last(1,1);
ans.push_back(last);
for(int i=2;i<=numRows;i++)
{
vector<int> curr(i,1);
for(int j=1;j<last.size();j++)
{
curr[j]=last[j-1]+last[j];
}
ans.push_back(curr);
last=curr;
}
return ans;
}
static Uint64 calculate(
size_t size,
size_t vertexCount,
const dataType* data
) {
if (vertexCount < 2) {
return 0;
}
typedef gmtl::Vec<dataType, 2> Vec;
const dataType* v = data;
Uint64 total = 0;
Vec last(v[0], v[1]); v += size;
for (size_t i = 1; i < vertexCount; ++i, v += size) {
total += Uint64(std::max(myabs(v[0] - last[0]),
myabs(v[1] - last[1])));
last = Vec(v[0], v[1]);
}
return total;
}
double ROCCurve::AUC()
{
if (score_clas_pairs_.empty())
{
std::cerr << "ROCCurve::AUC() : unsuitable dataset (no positives or no negatives)\n";
return 0.5;
}
score_clas_pairs_.sort(simsortdec());
// value that is not in score_clas_pairs_
double prevsim = score_clas_pairs_.begin()->first + 1;
UInt truePos = 0;
UInt falsePos = 0;
std::vector<DPosition<2> > polygon;
for (std::list<std::pair<double, bool> >::const_iterator cit = score_clas_pairs_.begin(); cit != score_clas_pairs_.end(); ++cit)
{
if (fabs(cit->first - prevsim) > 1e-8)
{
polygon.push_back(DPosition<2>((double)falsePos / neg_, (double)truePos / pos_));
}
if (cit->second)
{
++truePos;
}
else
{
++falsePos;
}
}
polygon.push_back(DPosition<2>(1, 1));
std::sort(polygon.begin(), polygon.end());
DPosition<2> last(0, 0);
double area(0);
for (std::vector<DPosition<2> >::const_iterator it = polygon.begin(); it != polygon.end(); ++it)
{
area += (it->getX() - last.getX()) * (it->getY());
last = *it;
}
return area;
}
/**
* @brief Create a sprite previewer.
* @param parent The parent object or nullptr.
*/
SpritePreviewer::SpritePreviewer(QWidget *parent) :
QWidget(parent),
model(nullptr),
zoom(1.0) {
ui.setupUi(this);
// Create frame and origin items.
item = new QGraphicsPixmapItem();
origin_h = new QGraphicsLineItem();
origin_v = new QGraphicsLineItem();
origin_h->setPen(QPen(Qt::blue));
origin_v->setPen(QPen(Qt::blue));
// Create the scene.
ui.frame_view->setScene(new QGraphicsScene());
ui.frame_view->scene()->addItem(item);
ui.frame_view->scene()->addItem(origin_h);
ui.frame_view->scene()->addItem(origin_v);
ui.frame_view->scene()->setBackgroundBrush(
ui.frame_view->scene()->palette().base());
// Zoom.
ui.zoom_button->setMenu(create_zoom_menu());
ui.zoom_button->setPopupMode(QToolButton::InstantPopup);
set_zoom(2.0);
update_zoom();
connect(&timer, SIGNAL(timeout()), this, SLOT(timeout()));
connect(ui.start_button, SIGNAL(clicked()), this, SLOT(start()));
connect(ui.stop_button, SIGNAL(clicked()), this, SLOT(stop()));
connect(ui.first_button, SIGNAL(clicked()), this, SLOT(first()));
connect(ui.previous_button, SIGNAL(clicked()), this, SLOT(previous()));
connect(ui.last_button, SIGNAL(clicked()), this, SLOT(last()));
connect(ui.next_button, SIGNAL(clicked()), this, SLOT(next()));
connect(ui.origin_check_box, SIGNAL(clicked()), this, SLOT(update_origin()));
}
void
AGActivityGen::generateOutputFile(std::list<AGTrip>& trips) {
AGActivityTripWriter atw(outputFile);
if (trips.size() != 0) {
std::list<AGTrip>::iterator it;
//variables for TESTS:
int firstTrip = trips.front().getTime() + trips.front().getDay() * 86400;
int lastTrip = trips.front().getTime() + trips.front().getDay() * 86400;
std::map<int, int> histogram;
for (int i = 0; i < 100; ++i) {
histogram[i] = 0;
}
//END var TESTS
for (it = trips.begin(); it != trips.end(); ++it) {
atw.addTrip(*it);
//TEST
if (it->getTime() + 86400 * it->getDay() > lastTrip) {
lastTrip = it->getTime() + 86400 * it->getDay();
}
if (it->getTime() + 86400 * it->getDay() < firstTrip) {
firstTrip = it->getTime() + 86400 * it->getDay();
}
//++histogram[((it->getDay()-1)*86400 + it->getTime())/3600];
++histogram[(it->getTime()) / 3600];
//END TEST
}
//PRINT TEST
AGTime first(firstTrip);
AGTime last(lastTrip);
std::cout << "first real trip: " << first.getDay() << ", " << first.getHour() << ":" << first.getMinute() << ":" << first.getSecond() << std::endl;
std::cout << "last real trip: " << last.getDay() << ", " << last.getHour() << ":" << last.getMinute() << ":" << last.getSecond() << std::endl;
for (int i = 0; i < 100; ++i) {
if (histogram[i] > 0) {
std::cout << "histogram[ hour " << i << " ] = " << histogram[i] << std::endl;
}
}
} else {
std::cout << "No real trips were generated" << std::endl;
}
}
void Cdmatest::FetchNodeResultsL( TInt /*aResultsRef*/, CBufBase& aObject,
const TDesC8& /*aType*/ )
{
TPtrC8 ptr( aObject.Ptr( 0 ) );
iLog->Log( _L8("FetchNodeResultsL for '%S': '%S'" ), iURI, &ptr );
if ( ptr.Length() > 0 )
{
TPtrC8 last( LastURISeg( ptr ) );
HBufC8 *oldUri = HBufC8::NewL( iURI->Length() );
(*oldUri) = *iURI;
do
{
iLog->Log ( _L8( " Node: '%S' "), &last );
HBufC8 *nUri = HBufC8::NewLC( oldUri->Length() + 1 + last.Length() );
nUri->Des().Copy( *oldUri ) ;
nUri->Des().Append( '/' );
nUri->Des().Append( last );
SetURIL( nUri );
//iResultsFunction = FetchNodeResultsL;
//TPtrC8 parentURI(RemoveLastSeg(*nUri));
//HBufC8 *luid = GetLuidAllocLC( parentURI );
CleanupStack::Pop( nUri );
HBufC8 *luid = GetLuidAllocLC( *iURI );
Adapter()->ChildURIListL( *nUri, KNullDesC8, *iEmptyMappingInfoArray, 4, 5 );//Dipak
CleanupStack::PopAndDestroy( luid );
ptr.Set( RemoveLastURISeg( ptr ) );
last.Set( LastURISeg( ptr ) );
}
while (last != KNullDesC8);
}
}
void test_stability(bool expect_stable) {
const unsigned kPopulationSize = 100;
int ia[kPopulationSize];
for (unsigned i = 0; i < kPopulationSize; ++i)
ia[i] = i;
PopulationIterator first(ia);
PopulationIterator last(ia + kPopulationSize);
const unsigned kSampleSize = 20;
int oa[kPopulationSize];
SampleIterator out(oa);
std::minstd_rand g;
const int kIterations = 1000;
bool unstable = false;
for (int i = 0; i < kIterations; ++i) {
std::experimental::sample(first, last, out, kSampleSize, g);
unstable |= !std::is_sorted(oa, oa + kSampleSize);
}
assert(expect_stable == !unstable);
}
QString DebconfFrontend::substitute(const QString &key, const QString &rest) const
{
Substitutions sub = m_subst[key];
QString result, var, escape;
QRegExp rx(QStringLiteral( "^(.*)(\\\\)?\\$\\{([^\\{\\}]+)\\}(.*)$" ));
QString last(rest);
int pos = 0;
while ( (pos = rx.indexIn(rest, pos)) != -1) {
qCDebug(DEBCONF) << "var found! at" << pos;
result += rx.cap(1);
escape = rx.cap(2);
var = rx.cap(3);
last = rx.cap(4);
if (!escape.isEmpty()) {
result += QString(QLatin1Literal( "${" ) % var % QLatin1Char( '}' ));
} else {
result += sub.value(var);
}
pos += rx.matchedLength();
}
return result + last;
}
int main()
{
int n, q;
while (scanf("%d%d", &n, &q) == 2) {
std::vector<int> a(n), first(n, -1), last(n);
int total = 0;
for (int i = 0; i < n; ++ i) {
scanf("%d", &a[i]);
a[i] --, last[a[i]] = i;
if (first[a[i]] == -1) {
total ++, first[a[i]] = i;
}
}
std::vector<Query> queries;
for (int i = 0, l, r; i < q; ++ i) {
scanf("%d%d", &l, &r);
queries.push_back(Query {l - 1, r - 1, i});
}
std::sort(queries.begin(), queries.end());
std::vector<int> count(n), result(q);
for (int i = 0, k = 0; i < n; ++ i) {
while (k < q && queries[k].r == i) {
int& ref = result[queries[k].id] = total;
for (int j = queries[k].l; j < n; j += ~j & j + 1) {
ref -= count[j];
}
k ++;
}
if (last[a[i]] == i) {
for (int j = first[a[i]] - 1; ~j; j -= ~j & j + 1) {
count[j] ++;
}
}
}
for (int i = 0; i < q; ++ i) {
printf("%d\n", result[i]);
}
}
}
void Reptation_method::get_avg(deque <Reptile_point> & reptile,
Properties_point & pt) {
int size=reptile.size();
int nwf=reptile[0].prop.kinetic.GetDim(0);
if(nwf >1) error("nwf > 0 not supported yet");
pt.setSize(nwf);
Reptile_point & last(reptile[size-1]);
//How to do averaging at either end. Not doing this right
//now because of correlated sampling..if we really want energies,
//usually DMC is a better choice.
pt=last.prop;
//Reptile_point & first(reptile[0]);
//pt.kinetic(0)=.5*(first.prop.kinetic(0)+last.prop.kinetic(0));
//pt.nonlocal(0)=.5*(first.prop.nonlocal(0)+last.prop.nonlocal(0));
//pt.potential(0)=.5*(first.prop.potential(0) + last.prop.potential(0));
pt.count=1;
pt.weight=1;
}
int countPalindromicSubsequences(string S) {
int n = S.size();
prev = vector<vector<int>>(n, vector<int>(4, -1));
next = vector<vector<int>>(n, vector<int>(4, -1));
dp = vector<vector<int>>(n, vector<int>(n));
vector<int> last(4, -1);
for (int i = 0; i < n; ++i) {
last[S[i] - 'a'] = i;
for (int j = 0; j < 4; ++j) {
prev[i][j] = last[j];
}
}
fill(last.begin(), last.end(), -1);
for (int i = n - 1; i >= 0; --i) {
last[S[i] - 'a'] = i;
for (int j = 0; j < 4; ++j) {
next[i][j] = last[j];
}
}
return dfs(S, 0, n - 1);
}
bool SVSet::isConsistent() const
{
#ifdef ENABLE_CONSISTENCY_CHECKS
DLPSV* ps;
DLPSV* next;
for (ps = list.first(); ps; ps = next)
{
if (!ps->isConsistent())
return MSGinconsistent("SVSet");
if (ps->mem() > &last())
return MSGinconsistent("SVSet");
next = list.next(ps);
if (next && ps->mem() + ps->max() + 1 != next->mem()) {
return MSGinconsistent("SVSet");
}
}
return DataArray < SVector::Element > ::isConsistent()
&& set.isConsistent() && list.isConsistent();
#else
return true;
#endif
}
/*!
\internal
\brief Records point to list with timestamp.
\param point Point to be recorded.
\param time Time to be recorded.
\return Nothing.
*/
void HbPointRecorder::record(qreal point, const QTime &time)
{
// Empty list always accepts first point without tests.
if ( !isEmpty() ) {
// No point to record a point, if timestamp is less or equal with previous.
if ( lastTime().msecsTo(time) == 0 ) {
DEBUG() << "Ignoring point, because no difference in time stamps.";
return;
}
// Don't tolerate points, which are too close to previously recorded point.
if ( qAbs(lastPoint() - point) < mThreshold ) {
DEBUG() << "Ignoring point, because it is withing threshold of previous point";
return;
}
}
// In case the list contains two or more points, direction can be
// determined. Each new point added needs to be checked for direction
// change.
if ( length() > 1 ) {
// Clear list, on direction change. Leave the last recorded point
// to the list, as it can be considered as first point for new direction.
if ( dirChanged( point ) ) {
HbPointTime temp = last();
clear();
append(temp);
}
}
// Finally check, if the position has changed. Don't record point, when no position
// change.
if ( isEmpty() || point != lastPoint() ) {
// Add point and time to list.
append(HbPointTime(point, time));
} else {
DEBUG() << "Ignoring point, because it equals previous.";
}
}
