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