void Spline::updateM(int lvl)
{
if (m_p.size() < 4)
{
m_q.clear();
return;
}
// Every segment is subdivided lvl times
//
int f = pow(2.0,lvl)+1;
VectorXd ranges(f);
// Ranges from 0 to 1
//
for (int i=0; i<f; ++i)
ranges(i) = (double)i/(f-1.0);
// Compute the subdivision matrix for a single segment
//
MatrixXd sM = MatrixXd::Zero(f,4);
MatrixXd A(4,4);
A << -1, 3, -3, 1,
3, -6, 3, 0,
-3, 0, 3, 0,
1, 4, 1, 0;
for (int i=0; i<f; ++i)
{
double t = ranges(i);
MatrixXd tm(4,1); tm << t*t*t, t*t, t, 1;
MatrixXd temp = tm.transpose()*(1.0/6.0)*A;
for(int j=0;j<4;++j)
sM(i,j) = temp(j);
}
int segmentCount = (int)m_p.size()-3;
int finalPointCount = (segmentCount * f) - (segmentCount-1);
M = MatrixXd::Zero(finalPointCount, m_p.size());
// Produce the set of final points and the global subdivision matrix
//
for (size_t m=1; m<m_p.size()-2; ++m)
{
int blockN = m-1;
int i = blockN*(f-1);
int j = blockN;
M.block(i, j, sM.rows(), sM.cols()) = sM;
}
m_q.resize(finalPointCount);
updateQ();
}
QgsLegendSymbologyList QgsGraduatedSymbolRendererV2::legendSymbologyItems( QSize iconSize )
{
QgsLegendSymbologyList lst;
int count = ranges().count();
for ( int i = 0; i < count; i++ )
{
const QgsRendererRangeV2& range = ranges()[i];
QPixmap pix = QgsSymbolLayerV2Utils::symbolPreviewPixmap( range.symbol(), iconSize );
lst << qMakePair( range.label(), pix );
}
return lst;
}
CUresult FindGlobalMax(MaxIndexEngine* engine, CUdeviceptr data, int count,
float* maxX, int* maxIndex) {
// Process 256 values a time .
int numBricks = DivUp(count, 256);
int numBlocks = std::min(numBricks, engine->numBlocks);
// Distribute the work along complete bricks.
div_t brickDiv = div(numBricks, numBlocks);
std::vector<int2> ranges(numBlocks);
for(int i(0); i < numBlocks; ++i) {
int2 range;
range.x = i ? ranges[i - 1].y : 0;
int bricks = (i < brickDiv.rem) ? (brickDiv.quot + 1) : brickDiv.quot;
range.y = std::min(range.x + bricks * 256, count);
ranges[i] = range;
}
engine->rangeMem->FromHost(ranges);
CuCallStack callStack;
callStack.Push(data, engine->maxMem, engine->indexMem, engine->rangeMem);
CUresult result = engine->pass1->Launch(numBlocks, 1, callStack);
if(CUDA_SUCCESS != result) return result;
callStack.Reset();
callStack.Push(engine->maxMem, engine->indexMem, numBlocks);
result = engine->pass2->Launch(1, 1, callStack);
if(CUDA_SUCCESS != result) return result;
// Retrieve the max elements.
engine->maxMem->ToHost(maxX, 1);
engine->indexMem->ToHost(maxIndex, 1);
return CUDA_SUCCESS;
}
CMlStaticStructLearn::CMlStaticStructLearn(CStaticGraphicalModel *pGrModel,
ELearningTypes LearnType,
EOptimizeTypes AlgorithmType,
EScoreFunTypes ScoreType, int nMaxFanIn,
intVector& vAncestor, intVector& vDescent)
:CStaticLearningEngine(pGrModel, LearnType),
m_pResultBNet(NULL), m_pResultDAG(NULL)
{
int nnodes = pGrModel->GetNumberOfNodes();
m_nNodes = nnodes;
int i;
for (i = 0; i<nnodes; i++) m_vResultRenaming.push_back(i);
m_ScoreType = ScoreType;
m_Algorithm = AlgorithmType;
m_nMaxFanIn = nMaxFanIn;
m_ScoreMethod = MaxLh;
m_priorType = Dirichlet;
m_K2alfa = 0;
m_vAncestor.assign(vAncestor.begin(), vAncestor.end());
m_vDescent.assign(vDescent.begin(),vDescent.end());
PNL_CHECK_RANGES(nMaxFanIn, 1, nnodes);
intVector ranges(nMaxFanIn);
for(i=0; i<nMaxFanIn; i++) ranges[i] = nnodes+1;
float max = 0.0f;
m_pNodeScoreCache = (CSparseMatrix<float>**)malloc(nnodes * sizeof(CSparseMatrix<float>*));
for(i=0; i<nnodes; i++)
{
m_pNodeScoreCache[i] = CSparseMatrix<float>::Create(nMaxFanIn,
&ranges.front(), max, 0);
}
}
/// basic test for line iteration
void RangeSetLineIteratorTest::testBasicIteration()
{
CharTextDocument doc;
doc.setText( QStringLiteral("a1|b2|c3|d4|e5|f6").replace("|","\n"));
TextRangeSet ranges(&doc);
ranges.addRange(0,0); // line: 0
ranges.addRange(1,1); // line: 0
ranges.addRange(2,7); // line: 0-2
ranges.addRange(12,15); // line: 4-5
RangeSetLineIterator itr(&ranges);
testTrue( itr.hasNext() );
testEqual( itr.next(), 0 );
testTrue( itr.hasNext() );
testEqual( itr.next(), 1 );
testTrue( itr.hasNext() );
testEqual( itr.next(), 2 );
testTrue( itr.hasNext() );
testEqual( itr.next(), 4 );
testTrue( itr.hasNext() );
testEqual( itr.next(), 5 );
testFalse( itr.hasNext() );
testEqual( itr.next(), -1 );
}
void ConvolutionLayer::im2col(Blob &inpBlob, int imNum, int cnGroup)
{
uchar *srcPtr = inpBlob.ptr(imNum, cnGroup*inpGroupCn);
if (is1x1())
{
colMat = Mat(ksize, inpBlob.rows()*inpBlob.cols(), inpBlob.type(), srcPtr);
return;
}
#ifdef HAVE_OPENCL
if (useOpenCL && ocl::useOpenCL() && inpBlob.type() == CV_32F && !is1x1())
{
std::vector<Range> ranges(4, Range::all());
ranges[0] = Range(imNum, imNum+1);
ranges[1] = Range(cnGroup*inpGroupCn, (cnGroup + 1)*inpGroupCn);
UMat src = inpBlob.matRef()(&ranges[0]).getUMat(ACCESS_READ);
UMat dst(colMat.size(), colMat.type());
im2col_ocl(src, inpGroupCn, inpH, inpW, kerH, kerW, padH, padW, strideH, strideW, dst);
dst.copyTo(colMat);
return;
}
#endif // HAVE_OPENCL
if (inpBlob.type() == CV_32F)
im2col_cpu((float *)srcPtr, inpGroupCn, inpH, inpW, kerH, kerW, padH, padW, strideH, strideW, (float *)colMat.ptr());
if (inpBlob.type() == CV_64F)
im2col_cpu((double*)srcPtr, inpGroupCn, inpH, inpW, kerH, kerW, padH, padW, strideH, strideW, (double*)colMat.ptr());
}
int main() {
while (true) {
int n;
scanf("%d", &n);
if (n == 0) break;
std::vector<Range> ranges(n);
int limit = 0;
for (int i = 0; i < n; ++i) {
scanf("%d %d", &ranges[i].s, &ranges[i].t);
ranges[i].id = i;
limit = std::max(limit, ranges[i].t);
}
std::sort(ranges.begin(), ranges.end());
std::vector<int> ans(n);
BinaryIndexedTree<int, std::plus<int> > bit(limit + 1);
for(int i = n - 1; i >= 0; --i) {
if(i != n-1 && ranges[i].t == ranges[i+1].t && ranges[i].s == ranges[i+1].s) {
ans[ranges[i].id] = ans[ranges[i+1].id];
} else {
ans[ranges[i].id] = bit.Query(ranges[i].s);
}
bit.Update(ranges[i].s, 1);
}
for (int i = 0; i < n; ++i) {
printf("%d%c", ans[i], (i==n-1)?'\n':' ');
}
}
return 0;
}
TEST(TestHttpRanges, Clear)
{
CHttpRange range_0(0, 2);
CHttpRange range_1(4, 6);
CHttpRange range_2(8, 10);
HttpRanges ranges_raw;
ranges_raw.push_back(range_0);
ranges_raw.push_back(range_1);
ranges_raw.push_back(range_2);
CHttpRanges ranges(ranges_raw);
CHttpRange range;
EXPECT_EQ(3U, ranges.Size());
EXPECT_TRUE(ranges.Get(0, range));
EXPECT_EQ(range_0, range);
EXPECT_TRUE(ranges.Get(1, range));
EXPECT_EQ(range_1, range);
EXPECT_TRUE(ranges.Get(2, range));
EXPECT_EQ(range_2, range);
ranges.Clear();
EXPECT_EQ(0U, ranges.Size());
}
ASBoolean SnpSelectionHelper::IsTextRangeSelected(void)
{
ASBoolean result = false;
if (this->IsDocumentSelected()) {
ATE::TextRangesRef rangesRef = NULL;
AIErr error = sAIDocument->GetTextSelection(&rangesRef);
aisdk::check_ai_error(error);
ATE::ITextRanges ranges(rangesRef);
if (ranges.GetSize() > 0) {
AIBoolean textFocus = false;
error = sAIDocument->HasTextFocus(&textFocus);
aisdk::check_ai_error(error);
if (textFocus) {
ATE::ITextRange textRange = ranges.Item(0);
if (textRange.GetSize() > 0)
result = true;
}
else
result = true;
}
}
return result;
}
TEST(TestHttpRanges, GetIndex)
{
CHttpRange range_0(0, 2);
CHttpRange range_1(4, 6);
CHttpRange range_2(8, 10);
HttpRanges ranges_raw;
ranges_raw.push_back(range_0);
ranges_raw.push_back(range_1);
ranges_raw.push_back(range_2);
CHttpRanges ranges(ranges_raw);
CHttpRange range;
EXPECT_TRUE(ranges.Get(0, range));
EXPECT_EQ(range_0, range);
EXPECT_TRUE(ranges.Get(1, range));
EXPECT_EQ(range_1, range);
EXPECT_TRUE(ranges.Get(2, range));
EXPECT_EQ(range_2, range);
EXPECT_FALSE(ranges.Get(3, range));
}
void compute( const FUNC& f, const X & ranges, const o_t & o)
{
init(o);
itab_t facts = ranges(nt2::_,begin_+1, nt2::_)-ranges(nt2::_,begin_, nt2::_);
itab_t vols = nt2::prod(facts);
input_t total_vol = globalasum1(vols);
itab_t coefs = real_t(maxfunccnt_)*nt2::abs(vols)*nt2::rec(total_vol);
BOOST_ASSERT_MSG(size(ranges, 2) == 2, "ranges must be a nx2xm expression");
size_t l = size(ranges, 3);
res_ = nt2::Zero<value_t>();
for(size_t i=1; i <= l; ++i)
{
nbpts_ = coefs(i);
res_ += compute(f, ranges(nt2::_,nt2::_,i), vols(i), facts(i));
fcnt_+= nbpts_;
}
}
size_t count(size_t max_count = std::numeric_limits<size_t>::max()) {
size_t result = 0;
for (auto& range : ranges())
for (auto i = range.first; i != range.second; ++i)
if (++result == max_count)
return max_count;
return result;
}
void
Quantizer::quantize(EventSelection *selection)
{
Q_ASSERT(m_toInsert.size() == 0);
Segment &segment = selection->getSegment();
m_normalizeRegion.first = segment.getStartTime();
m_normalizeRegion.second = segment.getEndTime();
// Attempt to handle non-contiguous selections.
// We have to be a bit careful here, because the rest-
// normalisation that's carried out as part of a quantize
// process is liable to replace the event that follows
// the quantized range. (moved here from editcommands.cpp)
EventSelection::RangeList ranges(selection->getRanges());
// So that we can retrieve a list of new events we cheat and stop
// the m_toInsert vector from being cleared automatically. Remember
// to turn it back on.
//
EventSelection::RangeList::iterator r = ranges.end();
while (r-- != ranges.begin()) {
/*
cerr << "Quantizer: quantizing range ";
if (r->first == segment.end()) {
cerr << "end";
} else {
cerr << (*r->first)->getAbsoluteTime();
}
cerr << " to ";
if (r->second == segment.end()) {
cerr << "end";
} else {
cerr << (*r->second)->getAbsoluteTime();
}
cerr << endl;
*/
quantizeRange(&segment, r->first, r->second);
}
// Push the new events to the selection
for (int i = 0; i < int(m_toInsert.size()); ++i) {
if (m_toInsert[i]->getAbsoluteTime() < segment.getEndTime()) {
// Select only the events inside the segment.
selection->addEvent(m_toInsert[i]);
}
}
// and then to the segment
insertNewEvents(&segment);
}
QgsLegendSymbologyList QgsGraduatedSymbolRendererV2::legendSymbologyItems( QSize iconSize )
{
QSettings settings;
bool showClassifiers = settings.value( "/qgis/showLegendClassifiers", false ).toBool();
QgsLegendSymbologyList lst;
if ( showClassifiers )
{
lst << qMakePair( classAttribute(), QPixmap() );
}
int count = ranges().count();
for ( int i = 0; i < count; i++ )
{
const QgsRendererRangeV2& range = ranges()[i];
QPixmap pix = QgsSymbolLayerV2Utils::symbolPreviewPixmap( range.symbol(), iconSize );
lst << qMakePair( range.label(), pix );
}
return lst;
}
Vector< MinMax > MatrixFloat::getRanges() const{
if( rows == 0 ) return Vector< MinMax >();
Vector< MinMax > ranges(cols);
for(unsigned int i=0; i<rows; i++){
for(unsigned int j=0; j<cols; j++){
ranges[j].updateMinMax( dataPtr[i*cols+j] );
}
}
return ranges;
}
void
setModeHistogramGroup(const std::string &statname,
const std::string &histogram_type,
const int bins,
std::list<double> &_ranges)
{
std::vector<double> ranges(_ranges.size());
copy(_ranges.begin(),_ranges.end(),ranges.begin());
StatsMaker::setModeHistogramGroup(statname,getHistMode(histogram_type),
bins,ranges);
}
QVector<SourceRangeContainer> Diagnostic::getSourceRangeContainers() const
{
auto rangeVector = ranges();
QVector<SourceRangeContainer> sourceRangeContainers;
sourceRangeContainers.reserve(rangeVector.size());
for (auto &&sourceRange : rangeVector)
sourceRangeContainers.push_back(sourceRange.toSourceRangeContainer());
return sourceRangeContainers;
}
std::vector< MinMax > MatrixDouble::getRanges() const{
if( rows == 0 ) return std::vector< MinMax >();
vector< MinMax > ranges(cols);
for(unsigned int i=0; i<rows; i++){
for(unsigned int j=0; j<cols; j++){
ranges[j].updateMinMax( dataPtr[i][j] );
}
}
return ranges;
}
// ----------------------------------------------------------------------------
//
void DefinitionWriter::visit( Channel* channel )
{
TiXmlElement channel_element( "channel" );
add_attribute( channel_element, "index", (DWORD)channel->m_channel_offset );
add_attribute( channel_element, "type", (LPCSTR)channel->convertChannelTypeToText( channel->m_type ) );
add_attribute( channel_element, "color", channel->isColor() );
add_attribute( channel_element, "blackout", channel->canBlackout() );
if ( channel->m_default_value )
add_attribute( channel_element, "value", channel->m_default_value );
if ( channel->m_pixel_index )
add_attribute( channel_element, "pixel", channel->m_pixel_index );
if ( channel->m_home_value )
add_attribute( channel_element, "home_value", channel->m_home_value );
if ( channel->m_head_number )
add_attribute( channel_element, "head", channel->m_head_number );
// Add dimmer
if ( channel->isDimmer() ) {
TiXmlElement dimmer( "dimmer" );
add_attribute( dimmer, "strobe", channel->m_dimmer_can_strobe );
add_attribute( dimmer, "lowest_intensity", channel->m_lowest_intensity );
add_attribute( dimmer, "highest_intensity", channel->m_highest_intensity );
add_attribute( dimmer, "off_intensity", channel->m_off_intensity );
channel_element.InsertEndChild( dimmer );
}
// Add strobe
if ( channel->isStrobe() ) {
TiXmlElement strobe( "strobe" );
add_attribute( strobe, "speed_slow", channel->m_strobe_slow );
add_attribute( strobe, "speed_fast", channel->m_strobe_fast );
add_attribute( strobe, "off", channel->m_strobe_off );
}
add_text_element( channel_element, "name", channel->m_name );
if ( channel->m_ranges.size() > 0 && channel->m_type != CHNLT_PAN && channel->m_type != CHNLT_TILT ) {
TiXmlElement ranges( "ranges" );
visit_array<ChannelValueRangeArray>( ranges, channel->m_ranges );
channel_element.InsertEndChild( ranges );
}
if ( channel->m_angles.size() > 0 ) {
TiXmlElement angles( "angles" );
visit_array<ChannelAngleArray>( angles, channel->m_angles );
channel_element.InsertEndChild( angles );
}
getParent().InsertEndChild( channel_element );
}
value_t compute(const FUNC &f, const X&ranges, const input_t & vol, input_t fact)
{
size_t n = size(ranges, 1);
BOOST_AUTO_TPL(r1, ranges(nt2::_, begin_));
BOOST_AUTO_TPL(r1ex, nt2::expand_to(r1, nt2::of_size(n, nbpts_)));
BOOST_AUTO_TPL(r2ex, nt2::expand_to(fact, nt2::of_size(n, nbpts_)));
BOOST_AUTO_TPL(rnd, nt2::rand(nt2::of_size(n, nbpts_), nt2::meta::as_<real_t>()));
BOOST_AUTO_TPL(x, nt2::fma(rnd, r2ex, r1ex));
BOOST_AUTO_TPL(z, f(x));
if (compute_err_)
err_ += nt2::Three<real_t>()*vol*nt2::real(nt2::globalstdev(z))/nt2::sqrt(tofloat(nbpts_));
return vol*nt2::globalmean(z);
}
JNIEXPORT void JNICALL
Java_org_apache_subversion_javahl_SVNClient_logMessages
(JNIEnv *env, jobject jthis, jstring jpath, jobject jpegRevision,
jobject jranges, jboolean jstopOnCopy, jboolean jdisoverPaths,
jboolean jincludeMergedRevisions, jobject jrevProps, jlong jlimit,
jobject jlogMessageCallback)
{
JNIEntry(SVNClient, logMessages);
SVNClient *cl = SVNClient::getCppObject(jthis);
if (cl == NULL)
{
JNIUtil::throwError(_("bad C++ this"));
return;
}
Revision pegRevision(jpegRevision, true);
if (JNIUtil::isExceptionThrown())
return;
JNIStringHolder path(jpath);
if (JNIUtil::isExceptionThrown())
return;
LogMessageCallback callback(jlogMessageCallback);
StringArray revProps(jrevProps);
if (JNIUtil::isExceptionThrown())
return;
// Build the revision range vector from the Java array.
Array ranges(jranges);
if (JNIUtil::isExceptionThrown())
return;
std::vector<RevisionRange> revisionRanges;
std::vector<jobject> rangeVec = ranges.vector();
for (std::vector<jobject>::const_iterator it = rangeVec.begin();
it < rangeVec.end(); ++it)
{
RevisionRange revisionRange(*it);
if (JNIUtil::isExceptionThrown())
return;
revisionRanges.push_back(revisionRange);
}
cl->logMessages(path, pegRevision, revisionRanges,
jstopOnCopy ? true: false, jdisoverPaths ? true : false,
jincludeMergedRevisions ? true : false,
revProps, jlimit, &callback);
}
void AiryInfoNoObs::checkSampler() const
{
if (this->_sampler.get()) return;
dbg<<"AiryNoObs sampler\n";
std::vector<double> ranges(1,0.);
double rmin = 1.1;
double rmax = 2./(_gsparams->shoot_accuracy * M_PI*M_PI);
dbg<<"rmin = "<<rmin<<std::endl;
dbg<<"rmax = "<<rmax<<std::endl;
// NB: don't need floor, since rhs is positive, so floor is superfluous.
ranges.reserve(int((rmax-rmin+2)/0.5+0.5));
for(double r=rmin; r<=rmax; r+=0.5) ranges.push_back(r);
this->_sampler.reset(new OneDimensionalDeviate(_radial, ranges, true, _gsparams));
}
TEST(TestHttpRanges, Remove)
{
CHttpRange range_0(0, 2);
CHttpRange range_1(4, 6);
CHttpRange range_2(8, 10);
HttpRanges ranges_raw;
ranges_raw.push_back(range_0);
ranges_raw.push_back(range_1);
ranges_raw.push_back(range_2);
CHttpRanges ranges(ranges_raw);
CHttpRange range;
EXPECT_EQ(3U, ranges.Size());
EXPECT_TRUE(ranges.Get(0, range));
EXPECT_EQ(range_0, range);
EXPECT_TRUE(ranges.Get(1, range));
EXPECT_EQ(range_1, range);
EXPECT_TRUE(ranges.Get(2, range));
EXPECT_EQ(range_2, range);
// remove non-existing range
ranges.Remove(ranges.Size());
EXPECT_EQ(3U, ranges.Size());
EXPECT_TRUE(ranges.Get(0, range));
EXPECT_EQ(range_0, range);
EXPECT_TRUE(ranges.Get(1, range));
EXPECT_EQ(range_1, range);
EXPECT_TRUE(ranges.Get(2, range));
EXPECT_EQ(range_2, range);
// remove first range
ranges.Remove(0);
EXPECT_EQ(2U, ranges.Size());
EXPECT_TRUE(ranges.Get(0, range));
EXPECT_EQ(range_1, range);
EXPECT_TRUE(ranges.Get(1, range));
EXPECT_EQ(range_2, range);
// remove last range
ranges.Remove(1);
EXPECT_EQ(1U, ranges.Size());
EXPECT_TRUE(ranges.Get(0, range));
EXPECT_EQ(range_1, range);
// remove remaining range
ranges.Remove(0);
EXPECT_EQ(0U, ranges.Size());
}
JNIEXPORT void JNICALL
Java_org_apache_subversion_javahl_SVNClient_merge__Ljava_lang_String_2Lorg_apache_subversion_javahl_types_Revision_2Ljava_util_List_2Ljava_lang_String_2ZLorg_apache_subversion_javahl_types_Depth_2ZZZ
(JNIEnv *env, jobject jthis, jstring jpath, jobject jpegRevision,
jobject jranges, jstring jlocalPath, jboolean jforce, jobject jdepth,
jboolean jignoreAncestry, jboolean jdryRun, jboolean jrecordOnly)
{
JNIEntry(SVNClient, merge);
SVNClient *cl = SVNClient::getCppObject(jthis);
if (cl == NULL)
{
JNIUtil::throwError(_("bad C++ this"));
return;
}
JNIStringHolder path(jpath);
if (JNIUtil::isExceptionThrown())
return;
Revision pegRevision(jpegRevision);
if (JNIUtil::isExceptionThrown())
return;
JNIStringHolder localPath(jlocalPath);
if (JNIUtil::isExceptionThrown())
return;
// Build the revision range vector from the Java array.
Array ranges(jranges);
if (JNIUtil::isExceptionThrown())
return;
std::vector<RevisionRange> revisionRanges;
std::vector<jobject> rangeVec = ranges.vector();
for (std::vector<jobject>::const_iterator it = rangeVec.begin();
it < rangeVec.end(); ++it)
{
RevisionRange revisionRange(*it);
if (JNIUtil::isExceptionThrown())
return;
revisionRanges.push_back(revisionRange);
}
cl->merge(path, pegRevision, revisionRanges, localPath,
jforce ? true:false, EnumMapper::toDepth(jdepth),
jignoreAncestry ? true:false, jdryRun ? true:false,
jrecordOnly ? true:false);
}
Vector<std::tuple<bool, unsigned, unsigned>> FunctionHasExecutedCache::getFunctionRanges(intptr_t id)
{
Vector<std::tuple<bool, unsigned, unsigned>> ranges(0);
auto findResult = m_rangeMap.find(id);
if (findResult == m_rangeMap.end())
return ranges;
RangeMap& map = m_rangeMap.find(id)->second;
for (auto& pair : map) {
const FunctionRange& range = pair.first;
bool hasExecuted = pair.second;
ranges.append(std::tuple<bool, unsigned, unsigned>(hasExecuted, range.m_start, range.m_end));
}
return ranges;
}
void WarningsModel::processPendingUpdates() {
LOG_DEBUG << m_PendingUpdates.size() << "updates to process";
QVector<int> roles;
roles << WarningsRole;
decltype(m_PendingUpdates) pendingUpdates;
m_PendingUpdates.swap(pendingUpdates);
Helpers::IndicesRanges ranges(pendingUpdates);
for (auto &r: ranges.getRanges()) {
QModelIndex indexFrom = mapFromSource(m_ArtworksListModel.index(r.first, 0));
QModelIndex indexTo = mapFromSource(m_ArtworksListModel.index(r.second, 0));
emit dataChanged(indexFrom, indexTo, roles);
}
}
TEST(TestHttpRanges, GetLength)
{
CHttpRange range_0(0, 2);
CHttpRange range_1(4, 6);
CHttpRange range_2(8, 10);
const uint64_t expectedLength = range_0.GetLength() + range_1.GetLength() + range_2.GetLength();
HttpRanges ranges_raw;
ranges_raw.push_back(range_0);
ranges_raw.push_back(range_1);
ranges_raw.push_back(range_2);
CHttpRanges ranges(ranges_raw);
EXPECT_EQ(expectedLength, ranges.GetLength());
}
value_t compute(const FUNC &f, const X&ranges, const input_t & vol, input_t fact)
{
size_t n = size(ranges, 1);
BOOST_AUTO_TPL(r1, ranges(nt2::_, begin_));
BOOST_AUTO_TPL(r1ex, nt2::expand_to(r1, nt2::of_size(n, nbpts_)));
BOOST_AUTO_TPL(r2ex, nt2::expand_to(fact, nt2::of_size(n, nbpts_)));
rtab_t rnd = nt2::quasi(n, nbpts_, nt2::meta::as_<real_t>());
BOOST_AUTO_TPL(x, nt2::fma(rnd, r2ex, r1ex));
BOOST_AUTO_TPL(z, f(x));
if (compute_err_)
{
real_t fnbpt = real_t(nbpts_);
err_ += nt2::pow(nt2::log(fnbpt), real_t(n))*nt2::Three<real_t>()*vol*nt2::real(nt2::globalstdev(z))/fnbpt;
}
return vol*nt2::globalmean(z);
}
TEST(TestHttpRanges, Size)
{
CHttpRange range_0(0, 2);
CHttpRange range_1(4, 6);
CHttpRange range_2(8, 10);
HttpRanges ranges_raw;
ranges_raw.push_back(range_0);
ranges_raw.push_back(range_1);
ranges_raw.push_back(range_2);
CHttpRanges ranges_empty;
EXPECT_EQ(0U, ranges_empty.Size());
CHttpRanges ranges(ranges_raw);
EXPECT_EQ(ranges_raw.size(), ranges.Size());
}
TEST(TestHttpRanges, GetLastPosition)
{
CHttpRange range_0(0, 2);
CHttpRange range_1(4, 6);
CHttpRange range_2(8, 10);
HttpRanges ranges_raw;
ranges_raw.push_back(range_0);
ranges_raw.push_back(range_1);
ranges_raw.push_back(range_2);
CHttpRanges ranges(ranges_raw);
uint64_t position;
EXPECT_TRUE(ranges.GetLastPosition(position));
EXPECT_EQ(range_2.GetLastPosition(), position);
}
