void KisKraSaveXmlVisitorTest::testCreateDomDocument() { KisDocument* doc = createCompleteDocument(); quint32 count = 0; QDomDocument dom; QDomElement image = dom.createElement("IMAGE"); // Legacy! KisSaveXmlVisitor visitor(dom, image, count, "", true); Q_ASSERT(doc->image()); QStringList list; doc->image()->lock(); KisCountVisitor cv(list, KoProperties()); doc->image()->rootLayer()->accept(cv); doc->image()->rootLayer()->accept(visitor); QCOMPARE((int)visitor.m_count, (int)cv.count()); //delete doc; }
/** * Get the number of vertices emanating from this vertex. * Get a count of laths representing the vertices emanating from the vertex * this lath represents. * * @return Count of laths. */ TqInt CqLath::cQvv() const { TqInt c = 1; // Start with this // Laths representing the edges that radiate from the associated vertex are obtained by // following the clockwise vertex links around the vertex. CqLath* pNext = cv(); const CqLath* pLast = this; while(NULL != pNext && this != pNext) { c++; pLast = pNext; pNext = pNext->cv(); } // If we hit a boundary, add the ec of this boundary edge and start again going backwards. // @warning Adding ccf for the boundary edge means that the lath represents a different vertex. if(NULL == pNext) { pLast = this; pNext = ccv(); // We know we are going to hit a boundary in this direction as well so we can just look for that // case as a terminator. while(NULL != pNext) { assert( pNext != this ); c++; pLast = pNext; pNext = pNext->ccv(); } // We have hit the boundary going the other way, so add the ccf of this boundary edge. c++; } return( c ); }
/** * Get the facets which share this vertex. * Get a list of laths which represent the facets which share the vertex this * lath represents. * * @return Pointer to an array of lath pointers. */ void CqLath::Qvf(std::vector<const CqLath*>& Result) const { TqInt len = cQvf(); const CqLath* pNext = cv(); Result.resize(len); TqInt index = 0; // Laths representing the edges that radiate from the associated vertex are obtained by // following the clockwise vertex links around the vertex. const CqLath *pTmpLath = this; Result[index++] = pTmpLath; while(NULL != pNext && this != pNext) { Result[index++] = pNext; pNext = pNext->cv(); } // If we hit a boundary, start again going backwards. if(NULL == pNext) { pNext = ccv(); // We know we are going to hit a boundary in this direction as well so we can just look for that // case as a terminator. while(NULL != pNext) { Result[index++] = pNext; pNext = pNext->ccv(); } } }
/** * Get the edges emanating from a vertex. * Get a list of laths representing the edges which emanate from the vertex * this lath represents. * * @return Pointer to an array of lath pointers. */ TqInt CqLath::cQve() const { TqInt len = 1; CqLath* pNext = cv(); const CqLath* pLast = this; while(NULL != pNext && this != pNext) { len++; pLast = pNext; pNext = pNext->cv(); } // If we hit a boundary, add the ec of this boundary edge and start again going backwards. // @warning Adding ccf for the boundary edge means that the lath represents a different vertex. if(NULL == pNext) { pLast = this; pNext = ccv(); // We know we are going to hit a boundary in this direction as well so we can just look for that // case as a terminator. while(NULL != pNext) { assert( pNext != this ); len++; pLast = pNext; pNext = pNext->ccv(); } // We have hit the boundary going the other way, so add the ccf of this boundary edge. len++; } return(len); }
void SurfPhase:: setCoveragesByName(std::string cov) { int kk = nSpecies(); int k; compositionMap cc; for (k = 0; k < kk; k++) { cc[speciesName(k)] = -1.0; } parseCompString(cov, cc); doublereal c; vector_fp cv(kk, 0.0); bool ifound = false; for (k = 0; k < kk; k++) { c = cc[speciesName(k)]; if (c > 0.0) { ifound = true; cv[k] = c; } } if (!ifound) { throw CanteraError("SurfPhase::setCoveragesByName", "Input coverages are all zero or negative"); } setCoverages(DATA_PTR(cv)); }
int max_fs_arity(const Constraint_Handle &c) { int max_arity=0; for(Constr_Vars_Iter cv(c); cv; cv++) if((*cv).var->kind() == Global_Var) max_arity = omega::max(max_arity,(*cv).var->get_global_var()->arity()); return max_arity; }
TEST(CLConditionVariable, Multi_process_for_Shared_Cond) { CLSharedMemory *psm = new CLSharedMemory("test_for_multi_process_for_shared_cond", 16); long *p = (long *)(psm->GetAddress()); *p = 0; long *flag = (long *)(((char *)p) + 8); *flag = 0; CLEvent event("test_for_event_auto"); CLProcess *process = new CLProcess(new CLProcessFunctionForExec); EXPECT_TRUE(process->Run((void *)"../test_for_exec/test_for_CLConditionVariable/main").IsSuccess()); CLMutex mutex("mutex_for_test_for_multi_process_for_shared_cond", MUTEX_USE_SHARED_PTHREAD); CLConditionVariable cv("test_conditoin_variable_for_multiprocess"); { CLCriticalSection cs(&mutex); while(*flag == 0) EXPECT_TRUE((cv.Wait(&mutex)).IsSuccess()); } EXPECT_EQ(*p, 5); EXPECT_TRUE(event.Wait().IsSuccess()); delete psm; }
void mark_cells_on_vertices(VertexIt seed, CellSeq& cell_seq, EltMarker& visited, int level, CellPred inside) { typedef typename VertexIt::grid_type grid_type; typedef GT gt; typedef typename gt::Cell Cell; typedef typename gt::Vertex Vertex; typedef typename gt::CellOnVertexIterator CellOnVertexIterator; while(! seed.IsDone()) { Vertex V = *seed; for(CellOnVertexIterator cv(V); ! cv.IsDone(); ++cv) if( inside(*cv)) { Cell C(*cv); if(visited(C) == 0) { visited[C] = level; cell_seq.append(C); } } ++seed; } }
int main() { Vector3DFast av(4,-2,5); Vector3DFast bv(2,5,-3); Vector3DFast cv(0,0,0); cv=av+bv; }
ExecStatus Distinct<View0,View1>::post(Home home, View0 x, View1 y) { if (x.assigned()) { GlbRanges<View0> xr(x); IntSet xs(xr); ConstSetView cv(home, xs); GECODE_ES_CHECK((DistinctDoit<View1>::post(home,y,cv))); } if (y.assigned()) { GlbRanges<View1> yr(y); IntSet ys(yr); ConstSetView cv(home, ys); GECODE_ES_CHECK((DistinctDoit<View0>::post(home,x,cv))); } (void) new (home) Distinct<View0,View1>(home,x,y); return ES_OK; }
float CGameHelper::GuiTraceRay(const float3 &start, const float3 &dir, float length, CUnit*& hit, bool useRadar, CUnit* exclude) { if (dir == ZeroVector) { return -1.0f; } // distance from start to ground intersection point + fudge float groundLen = ground->LineGroundCol(start, start + dir * length); float returnLenSq = Square( (groundLen > 0.0f)? groundLen + 200.0f: length ); hit = NULL; CollisionQuery cq; GML_RECMUTEX_LOCK(quad); // GuiTraceRay vector<int> quads = qf->GetQuadsOnRay(start, dir, length); vector<int>::iterator qi; for (qi = quads.begin(); qi != quads.end(); ++qi) { const CQuadField::Quad& quad = qf->GetQuad(*qi); std::list<CUnit*>::const_iterator ui; for (ui = quad.units.begin(); ui != quad.units.end(); ++ui) { CUnit* unit = *ui; if (unit == exclude) { continue; } if ((unit->allyteam == gu->myAllyTeam) || gu->spectatingFullView || (unit->losStatus[gu->myAllyTeam] & (LOS_INLOS | LOS_CONTRADAR)) || (useRadar && radarhandler->InRadar(unit, gu->myAllyTeam))) { CollisionVolume cv(unit->collisionVolume); if (unit->isIcon) { // for iconified units, just pretend the collision // volume is a sphere of radius <unit->IconRadius> cv.SetDefaultScale(unit->iconRadius); } if (CCollisionHandler::MouseHit(unit, start, start + dir * length, &cv, &cq)) { // get the distance to the ray-volume egress point // so we can still select stuff inside factories const float len = (cq.p1 - start).SqLength(); if (len < returnLenSq) { returnLenSq = len; hit = unit; } } } } } return ((hit)? math::sqrt(returnLenSq): (math::sqrt(returnLenSq) - 200.0f)); }
table< T > compute_covariance( const storage< T, L >& sto ) { auto nchannels = sto.channel_size(); auto nframes = sto.frame_size(); auto means = compute_channel_means( sto ); table< T, L > cv( nchannels, nchannels ); for ( size_t row = 0; row < nchannels; ++row ) { for ( size_t col = 0; col < nchannels; ++col ) { T v = T( 0 ); for ( index_t i = 0; i < sto.frame_size(); ++i ) v += ( sto( i, row ) - means[ row ] ) * ( sto( i, col ) - means[ col ] ); cv( row, col ) = v / nframes; } } return cv; }
clRowEntry::clRowEntry(clTreeCtrl* tree, const wxString& label, int bitmapIndex, int bitmapSelectedIndex) : m_tree(tree) , m_model(tree ? &tree->GetModel() : nullptr) { // Fill the verctor with items constructed using the _non_ default constructor // to makes sure that IsOk() returns TRUE m_cells.resize(m_tree->GetHeader()->empty() ? 1 : m_tree->GetHeader()->size(), clCellValue("", -1, -1)); // at least one column clCellValue cv(label, bitmapIndex, bitmapSelectedIndex); m_cells[0] = cv; }
nsPagePrintTimer::~nsPagePrintTimer() { // "Destroy" the document viewer; this normally doesn't actually // destroy it because of the IncrementDestroyRefCount call below // XXX This is messy; the document viewer should use a single approach // to keep itself alive during printing nsCOMPtr<nsIContentViewer> cv(do_QueryInterface(mDocViewerPrint)); if (cv) { cv->Destroy(); } }
void AgeLength::DoExecute() { auto age_length = model_->managers().age_length()->FindAgeLength(age_length_label_); if (!age_length) LOG_FATAL() << "Could not find age_length " << age_length_label_ << " for the report"; unsigned min_age = model_->min_age(); unsigned max_age = model_->max_age(); unsigned year = model_->current_year(); unsigned time_steps = model_->time_steps().size(); // Print the header cache_ << "*"<< type_ << "[" << label_ << "]" << "\n"; cache_ << "year: " << model_->current_year() << "\n"; cache_ << "time_step: " << time_step_ << "\n"; cache_ << "year time_step "; for (unsigned age = min_age; age <= max_age; ++age) cache_ << age << " "; cache_ << "\n"; for (unsigned time_step = 0; time_step < time_steps; ++time_step) { cache_ << year << " " << time_step << " "; for (unsigned age = min_age; age <= max_age; ++age) cache_ << age_length->cv(year, time_step, age) << " "; cache_ << "\n"; } cache_ << "\n\n"; cache_ << "year time_step "; cache_ << "age "; for (auto length : model_->length_bins()) cache_ << "L(" << length << ") "; cache_ << "\n"; unsigned start_year = model_->start_year(); auto age_lengths = model_->partition().age_length_proportions(category_); // map<category, vector<year, time_step, age, length, proportion>>; for (unsigned i = 0; i < age_lengths.size(); ++i) { if (std::find(years_.begin(), years_.end(), i + start_year) != years_.end()) { for (unsigned j = 0; j < age_lengths[i].size(); ++j) { for (unsigned k = 0; k < age_lengths[i][j].size(); ++k) { cache_ << (start_year + i) << " " << j << " " << (min_age + k) << " "; for (unsigned l = 0; l < age_lengths[i][j][k].size(); ++l) { cache_ << age_lengths[i][j][k][l] << " "; } cache_ << "\n"; } } } } ready_for_writing_ = true; }
vector<ContourIndex::ContourPointIdx> ContourIndex::kNearestNeighbors(int k, Contour::ContourPart contourPoint) { vector<double> qData(numDimensions); qData.push_back(contourPoint->x); qData.push_back(contourPoint->y); qData.push_back(contourPoint->gradientAngleSmooth.normalize().degree()); qData.push_back(contourPoint->curvature.normalize().degree()); SpatialIndex::Point query(&qData[0], numDimensions); CollectIndicesVisitor cv(this); tree->nearestNeighborQuery(k, query, cv); return cv.result; }
TouchClassifier::~TouchClassifier() { #ifdef RETRAIN_THE_CLASSIFIER std::cout << "training the color classifier..." << std::endl; ColorClassifier::CrossValidator cv(3); //cv(60); ColorClassifier::KnownSampleSet trainingSet; cv.retrieveTrainingSamples(trainingSet); _colorClassifier->train(trainingSet); #endif delete _colorClassifier; cvReleaseImage(&_transformedColorImage); }
/* N.B., c_eval_seq discards CAR(values) so pass it an extra value. */ static cv_t c_eval_seq(obj_t cont, obj_t values) { assert(is_cont4(cont)); obj_t env = cont_env(cont); obj_t exprs = cont4_arg(cont); EVAL_LOG("exprs=%O", exprs); obj_t second = cont_cont(cont); if (!is_null(CDR(exprs))) second = make_cont4(c_eval_seq, second, env, CDR(exprs)); obj_t first = make_cont4(c_eval, second, env, CAR(exprs)); return cv(first, CDR(values)); }
static cv_t default_handler(obj_t cont, obj_t values) { /* * For all non-message-irritants-who conditions, * print the condition's class. * For all message conditions, print the condition's message. * If who or irritants given, print (cons who irritants). */ assert(is_cont(cont)); EVAL_LOG("cont=%O values=%O", cont, values); obj_t ex = CAR(values); obj_t parts = record_get_field(ex, 0); const char *psn = program_short_name(); size_t psnl = strlen(psn); size_t i, size = vector_len(parts); for (i = 0; i < size; i++) { obj_t rtd = record_rtd(vector_ref(parts, i)); if (rtd != message && rtd != irritants && rtd != who) { ofprintf(stderr, "%*s: %O\n", (int)psnl, psn, rtd_name(rtd)); psn = ""; } } obj_t who_p = FALSE_OBJ; obj_t irr_p = make_uninitialized(); for (i = 0; i < size; i++) { obj_t p = vector_ref(parts, i); obj_t rtd = record_rtd(p); if (rtd == message) { obj_t msg = record_get_field(p, 0); const wchar_t *chars = string_value(msg); fprintf(stderr, "%*s %ls\n", (int)psnl, psn, chars); psn = ""; } else if (rtd == who) who_p = record_get_field(p, 0); else if (rtd == irritants) irr_p = record_get_field(p, 0); } if (who_p != FALSE_OBJ && !is_uninitialized(irr_p)) { ofprintf(stderr, "%*s %O\n", (int)psnl, psn, CONS(who_p, irr_p)); psn = ""; } else if (who_p != FALSE_OBJ) { ofprintf(stderr, "%*s %O\n", (int)psnl, psn, who_p); psn = ""; } else if (!is_uninitialized(irr_p)) { ofprintf(stderr, "%*s %O\n", (int)psnl, psn, irr_p); psn = ""; } if (*psn) fprintf(stderr, "%s: unknown exception\n", psn); ofprintf(stderr, "\n"); return cv(EMPTY_LIST, CONS(make_uninitialized(), EMPTY_LIST)); }
cvec cofdm_sel::get_sel( ) { cvec cv; int K = sel_carriers.length(); int i; cv.set_length(K); for (i=0; i<K; i++) { cv(i)= y0(sel_carriers(i)); } return (cv); }
/* Runs the convert chain */ static int convert_chain(int c, ...) { va_list list; char_cv_t cv; va_start(list,c); while (cv = va_arg(list,char_cv_t), cv) { c = cv(c); } va_end(list); return c; }
void likelihood() { /* writes the log-likelihood given current parameter values */ /* set sum over log-likelihood to zero */ set_metr_ltotnew(0.0); set_metr_number_ok(0); /* loop over data */ int numdata = table_numrows("mydata"); for(int ii=0 ; ii<numdata ; ii++) { double y = table_getvalue("mydata","y",ii); /* if this val came from dist 1 */ double prob1 = normal_density(y, cv("mean1"), cv("sigma1")); /* if this val came from dist 1 */ double prob2 = normal_density(y, cv("mean2"), cv("sigma2")); /* weighted prob */ double prob3 = prob1*cv("q") + prob2*( 1.0 - cv("q") ); inc_metr_ltotnew(log(prob3)); inc_metr_number_ok(1); } return; }
TEST(CircularValue_NegativeRange, AssignBorder) { // additions { cv_type cv(-20); EXPECT_EQ(-10, cv + 10); } { cv_type cv(-20); EXPECT_EQ(-100, cv + 11); } { cv_type cv(-20); EXPECT_EQ(-99, cv + 12); } // subtractions { cv_type cv(-90); EXPECT_EQ(-100, cv - 10); } { cv_type cv(-90); EXPECT_EQ(-10, cv - 11); } { cv_type cv(-90); EXPECT_EQ(-11, cv - 12); } }
std::auto_ptr<Radiometer> MergeRadiometers( std::vector<const Radiometer *> & vr) { // Number of radiometers const size_t nr( vr.size() ); // The merged frequency grid std::vector<double> fg; // The vector of coeffiecients std::vector< std::vector<double> > cv( nr); // The vector iterators std::vector< RadioIter > iv; for ( size_t i =0 ; i < nr ; ++i ) iv.push_back(RadioIter(vr[i], 0)); std::vector< RadioIter >::iterator iv_first= iv.begin(); while (true) { // i is the radiometer with the smallest current frequency in // the set. std::vector< RadioIter >::iterator i = std::min_element( iv.begin(), iv.end() ); if (i->atend()) { // we are done break; } fg.push_back( * (i->f_i) ); for (size_t j = 0 ; j < nr ; ++j) { if ( (i- iv_first) == (int)j) { cv[j].push_back( *(i->c_i) ); } else { cv[j].push_back(0.0 ); } } i->advance(); } return std::auto_ptr<Radiometer> ( new Radiometer( fg, cv)); }
void likelihood() { /* writes the log-likelihood given current parameter values */ int ii; double prob1; double lambda, ph, depth, moss, count; double phref=7.0, depthref=10.0, mossref=0.0; /* set sum over log-likelihood to zero */ set_metr_ltotnew(0.0); set_metr_number_ok(0); /* loop over data */ for(ii=0 ; ii<numdata ; ii++) { ph = table_getvalue("mydata","ph",ii); depth = table_getvalue("mydata","depth",ii); moss = table_getvalue("mydata","moss",ii); count = table_getvalue("mydata","count",ii); /* calc lambda */ lambda = cv("beta") + cv("m0")*exp( cv("gph")*(ph-phref) + cv("gdepth")*(depth-depthref) + cv("gmoss")*(moss-mossref)); /* prob of observed count */ prob1 = poisson_density((int)count,lambda); if(prob1<0.000000010) prob1 = 0.000000010; // write prediction into data structure (nb would not be allowable under OMP parallel chains: serial chains only) table_writevalue("mydata","predlambda",ii,lambda); table_writevalue("mydata","simulatedcount",ii,poisson_draw(lambda)); // add log prob to sum inc_metr_ltotnew(log(prob1)); inc_metr_number_ok(1); } return; } // end of likelihood function
static cv_t c_continue_define(obj_t cont, obj_t values) { assert(is_cont5(cont)); EVAL_LOG("var=%O values=%O", cont5_arg1(cont), values); /* N.B., allocate new values before mutating environment. */ obj_t new_values = CONS(make_unspecified(), cont5_arg2(cont)); obj_t ret = cont_cont(cont); env_bind(cont_env(cont), cont5_arg1(cont), BT_LEXICAL, M_MUTABLE, CAR(values)); return cv(ret, new_values); }
static already_AddRefed<nsIDocument> document(nsIDocShell *aDocShell) { nsCOMPtr<nsIContentViewer> cv(doc_viewer(aDocShell)); if (!cv) return nsnull; nsCOMPtr<nsIDOMDocument> domDoc; cv->GetDOMDocument(getter_AddRefs(domDoc)); if (!domDoc) return nsnull; nsIDocument *result = nsnull; CallQueryInterface(domDoc, &result); return result; }
std::complex<T> hankel_imp(T v, T x, const bessel_no_int_tag&, const Policy& pol, int sign) { BOOST_MATH_STD_USING static const char* function = "boost::math::cyl_hankel_1<%1%>(%1%,%1%)"; if(x < 0) { bool isint_v = floor(v) == v; T j, y; bessel_jy(v, -x, &j, &y, need_j | need_y, pol); std::complex<T> cx(x), cv(v); std::complex<T> j_result, y_result; if(isint_v) { int s = (iround(v) & 1) ? -1 : 1; j_result = j * s; y_result = T(s) * (y - (2 / constants::pi<T>()) * (log(-x) - log(cx)) * j); } else { j_result = pow(cx, v) * pow(-cx, -v) * j; T p1 = pow(-x, v); std::complex<T> p2 = pow(cx, v); y_result = p1 * y / p2 + (p2 / p1 - p1 / p2) * j / tan(constants::pi<T>() * v); } // multiply y_result by i: y_result = std::complex<T>(-sign * y_result.imag(), sign * y_result.real()); return j_result + y_result; } if(x == 0) { if(v == 0) { // J is 1, Y is -INF return std::complex<T>(1, sign * -policies::raise_overflow_error<T>(function, 0, pol)); } else { // At least one of J and Y is complex infinity: return std::complex<T>(policies::raise_overflow_error<T>(function, 0, pol), sign * policies::raise_overflow_error<T>(function, 0, pol)); } } T j, y; bessel_jy(v, x, &j, &y, need_j | need_y, pol); return std::complex<T>(j, sign * y); }
static inline long do_const_sync(c_block *A, sort_info *B,char *flagB, long posA,long posB, long *begin,long *end,long *offset){ char *flagA=A->flags; long ret=0; if(flagB==NULL) ret=i_paranoia_overlap(cv(A),iv(B),posA,posB, cs(A),is(B),begin,end); else if((flagB[posB]&2)==0) ret=i_paranoia_overlap2(cv(A),iv(B),flagA,flagB,posA,posB,cs(A), is(B),begin,end); if(ret>MIN_WORDS_SEARCH){ *offset=+(posA+cb(A))-(posB+ib(B)); *begin+=cb(A); *end+=cb(A); return(ret); } return(0); }
void MusicPlaylistFoundItemWidget::downLoadFinished(const QByteArray &data) { QPixmap pix; pix.loadFromData(data); if(!pix.isNull()) { QPixmap cv(":/image/lb_album_cover"); cv = cv.scaled(m_iconLabel->size()); pix = pix.scaled(m_iconLabel->size()); MusicUtils::Widget::fusionPixmap(pix, cv, QPoint(0, 0)); m_iconLabel->setPixmap(pix); } m_topListenButton->raise(); m_playButton->raise(); }