void EinsplineSetLocal::evaluate (const ParticleSet& P, int iat, ValueVector_t& psi) { PosType r (P.R[iat]); PosType ru(PrimLattice.toUnit(P.R[iat])); ru[0] -= std::floor (ru[0]); ru[1] -= std::floor (ru[1]); ru[2] -= std::floor (ru[2]); for(int j=0; j<OrbitalSetSize; j++) { complex<double> val; Orbitals[j]->evaluate(ru, val); double phase = -dot(r, Orbitals[j]->kVec); double s,c; sincos (phase, &s, &c); complex<double> e_mikr (c,s); val *= e_mikr; #ifdef QMC_COMPLEX psi[j] = val; #else psi[j] = real(val); #endif } }
TEST( RocksRecoveryUnitTest, Simple1 ) { unittest::TempDir td( _rocksRecordStoreTestDir ); scoped_ptr<rocksdb::DB> db( getDB( td.path() ) ); db->Put( rocksdb::WriteOptions(), "a", "b" ); string value; db->Get( rocksdb::ReadOptions(), "a", &value ); ASSERT_EQUALS( value, "b" ); { RocksRecoveryUnit ru( db.get(), false ); ru.beginUnitOfWork(); ru.writeBatch()->Put( "a", "c" ); value = "x"; db->Get( rocksdb::ReadOptions(), "a", &value ); ASSERT_EQUALS( value, "b" ); ru.endUnitOfWork(); value = "x"; db->Get( rocksdb::ReadOptions(), "a", &value ); ASSERT_EQUALS( value, "c" ); } }
void main() { ru(num); int *min,*max,*m,*n,t,h; max=min=num; for(m=num+1;m<num+10;m++) { if(*m>*max) { max=m; } } t=num[9]; num[9]=*max; *max=t; for(n=num+1;n<num+10;n++) { if(*n<*min) { min=n; } } h=num[0]; num[0]=*min; num[0]=h; chu (num); }
int score(vector< map<int,float> > & reco){ int ret = 0; for(map<int,int>::iterator k = test_data.begin(); k != test_data.end(); ++k){ vector< pair<int,float> > ru(reco[k->first].begin(), reco[k->first].end()); sort(ru.begin(), ru.end(), GreaterSecond<int,float>); for(int i = 0; i < ru.size() && i < 10; ++i){ if(ru[i].first == k->second){ ++ret; break; } } } return ret; }
int main() { char s[100]; char p[100]; get(s,0,10); get(p,100,10); ru(s,p); //out: asm("int3"); return 0; }
int ru(char *s,char *p) { while(*s != '\0') { if(*p == '*') { if(ru(s + 1,p)) { return 1; } } else { if(*s != *p) { return 0; } s++; } p++; } return (*s) == (*p); }
void EinsplineSetLocal::evaluate (const ParticleSet& P, int first, int last, ValueMatrix_t& vals, GradMatrix_t& grads, ValueMatrix_t& lapls) { for(int iat=first,i=0; iat<last; iat++,i++) { PosType r (P.R[iat]); PosType ru(PrimLattice.toUnit(r)); ru[0] -= std::floor (ru[0]); ru[1] -= std::floor (ru[1]); ru[2] -= std::floor (ru[2]); complex<double> val; TinyVector<complex<double>,3> gu; Tensor<complex<double>,3> hess; complex<double> eye (0.0, 1.0); for(int j=0; j<OrbitalSetSize; j++) { complex<double> u; TinyVector<complex<double>,3> gradu; complex<double> laplu; Orbitals[j]->evaluate(ru, val, gu, hess); u = val; gradu = dot(PrimLattice.G, gu); laplu = trace(hess, GGt); PosType k = Orbitals[j]->kVec; TinyVector<complex<double>,3> ck; ck[0]=k[0]; ck[1]=k[1]; ck[2]=k[2]; double s,c; double phase = -dot(r, k); sincos (phase, &s, &c); complex<double> e_mikr (c,s); #ifdef QMC_COMPLEX vals(j,i) = e_mikr * u; grads(i,j) = e_mikr*(-eye*u*ck + gradu); lapls(i,j) = e_mikr*(-dot(k,k)*u - 2.0*eye*dot(ck,gradu) + laplu); #else vals(j,i) = real(e_mikr * u); grads(i,j) = real(e_mikr*(-eye*u*ck + gradu)); lapls(i,j) = real(e_mikr*(-dot(k,k)*u - 2.0*eye*dot(ck,gradu) + laplu)); #endif } } }
void EinsplineSetLocal::evaluate (const ParticleSet& P, int iat, ValueVector_t& psi, GradVector_t& dpsi, ValueVector_t& d2psi) { PosType r (P.R[iat]); PosType ru(PrimLattice.toUnit(P.R[iat])); ru[0] -= std::floor (ru[0]); ru[1] -= std::floor (ru[1]); ru[2] -= std::floor (ru[2]); complex<double> val; TinyVector<complex<double>,3> gu; Tensor<complex<double>,3> hess; complex<double> eye (0.0, 1.0); for(int j=0; j<OrbitalSetSize; j++) { complex<double> u; TinyVector<complex<double>,3> gradu; complex<double> laplu; Orbitals[j]->evaluate(ru, val, gu, hess); u = val; // Compute gradient in cartesian coordinates gradu = dot(PrimLattice.G, gu); laplu = trace(hess, GGt); PosType k = Orbitals[j]->kVec; TinyVector<complex<double>,3> ck; ck[0]=k[0]; ck[1]=k[1]; ck[2]=k[2]; double s,c; double phase = -dot(P.R[iat], k); sincos (phase, &s, &c); complex<double> e_mikr (c,s); #ifdef QMC_COMPLEX psi[j] = e_mikr * u; dpsi[j] = e_mikr*(-eye * ck * u + gradu); d2psi[j] = e_mikr*(-dot(k,k)*u - 2.0*eye*dot(ck,gradu) + laplu); #else psi[j] = real(e_mikr * u); dpsi[j] = real(e_mikr*(-eye * ck * u + gradu)); d2psi[j] = real(e_mikr*(-dot(k,k)*u - 2.0*eye*dot(ck,gradu) + laplu)); #endif } }
void XHScrollBar::OnMouseDown(XPoint &pt,int iPos) { if(iPos) return; if(m_nRange<=0) return; XRect r; GetClientRect(r); XRect ru(0,0,r.bottom,r.bottom); XRect rd(r.right-r.bottom,0,r.right,r.bottom); int pp; CalcRect(r,pp); m_nStatus=XS_NONE; if(ru.PtInRect(pt)) m_nStatus=XS_UPLINE; else if(rd.PtInRect(pt)) m_nStatus=XS_DOWNLINE; else if(pt.x<r.left) { m_nStatus=XS_UPPAGE; m_nDownPos=(pt.x-((r.left+r.right)>>1))*1000/pp+m_nPos; }
void QDCDDActor::sl_onAlgorithmTaskFinished() { QList<SharedAnnotationData> res; QMapIterator<RemoteBLASTTask*, int> iter(offsetMap); while (iter.hasNext()) { iter.next(); RemoteBLASTTask* rqt = iter.key(); QList<SharedAnnotationData> annotations = rqt->getResultedAnnotations(); //shift by offset int offset = offsetMap.value(rqt); QMutableListIterator<SharedAnnotationData> annIter(annotations); while (annIter.hasNext()) { QVector<U2Region>& location = annIter.next()->location->regions; U2Region::shift(offset, location); } res << annotations; } offsetMap.clear(); int minLen = cfg->getParameter(MIN_RES_LEN)->getAttributeValueWithoutScript<int>(); int maxLen = cfg->getParameter(MAX_RES_LEN)->getAttributeValueWithoutScript<int>(); const QString& qualVal = cfg->getParameter(QUAL_ATTR)->getAttributeValueWithoutScript<QString>(); foreach (const SharedAnnotationData& ad, res) { const U2Region& reg = ad->location->regions.first(); if (reg.length < minLen || reg.length > maxLen) { continue; } foreach(const U2Qualifier& qual, ad->qualifiers) { if (qual.value.contains(qualVal)) { QDResultUnit ru(new QDResultUnitData); ru->strand = ad->getStrand(); ru->quals = ad->qualifiers; ru->region = reg; ru->owner = units.values().first(); QDResultGroup* g = new QDResultGroup(QDStrand_Both); g->add(ru); results.append(g); break; } } } }
void octreeSolid::computeBoxAndVolume(octreeSNode *node) { if (node->bEnd) { // Leaf node node->leftDownTight = node->leftDownf; node->rightUpTight = node->rightUpf; node->volumef = volumeRectf((node->rightUpTight - node->leftDownTight)); } else { Vec3f ld(MAX, MAX, MAX); Vec3f ru(MIN, MIN, MIN); node->volumef = 0; for (int i = 0; i < 8; i++) { if (node->children[i]) { computeBoxAndVolume(node->children[i]); node->volumef += node->children[i]->volumef; for (int j = 0; j < 3; j ++) { if (ld[j] > node->children[i]->leftDownTight[j]) { ld[j] = node->children[i]->leftDownTight[j]; } if (ru[j] < node->children[i]->rightUpTight[j]) { ru[j] = node->children[i]->rightUpTight[j]; } } } } node->leftDownTight = ld; node->rightUpTight = ru; } }
void SurfaceObj::computeCenterPoint() { int i; Vec3f ld(MAX, MAX, MAX); Vec3f ru(MIN, MIN, MIN); for (i = 0; i < Point.size(); i++) { for (int j = 0; j < 3; j++) { if (ld[j] > Point[i][j]) { ld[j] = Point[i][j]; } if (ru[j] < Point[i][j]) { ru[j] = Point[i][j]; } } } MidPoint = (ld + ru) / 2; }
/** Given a graph, select k random start vertices. Call these k vertices set S. For all vertices v in the graph, find the farthest distance between v and any of the vertices in S. Store this is distField. Note that this implementation is faster than running K separate BFSs in parallel because all k BFSs share a frontier. This means that for each node we must store a bit vector of size K bits, indicating whether or not a node has been visited yet by the kth BFS. Note that a node v will continue to be added to the frontier as long as its source vertex u has a different bit vector than it. This means that v is being visited for the first time by at least one of the K BFSs. Thus we must also increment our estimate of its radius since the radius is the FARTHEST distance of node v to any of the u source vertices. At the end of the algorithm distField will contain the maximum distance from each node v in the graph to any of the K source nodes. The final radius estimate of the graph is obtained by taking the max radius obtained from all nodes in the graph. Note that this is an estimate because we only ran a BFS from K nodes. If we wanted an exact radius we would have had to run a BFS from every single node in the graph. **/ void kBFS(graph *g, int *distField) { int** visited; int** nextVisited; int* radii; int iter = 0; // set up globals #pragma omp parallel for schedule(static) for (int i = 0; i < g->num_nodes; i++) distField[i] = NA; radii = distField; visited = (int**) malloc(sizeof(int*) * g->num_nodes); nextVisited = (int**) malloc(sizeof(int*) * g->num_nodes); for (int i = 0; i < g->num_nodes; i++) { visited[i] = (int*) malloc(sizeof(int) * NUMWORDS); nextVisited[i] = (int*) malloc(sizeof(int) * NUMWORDS); memset(visited[i], 0, sizeof(int) * NUMWORDS); memset(nextVisited[i], 0, sizeof(int) * NUMWORDS); } // initialize the frontier with K random nodes srand(0); int numSources = std::min(K, g->num_nodes); int S[numSources]; // the set of source nodes for (int i = 0; i < numSources; i++) S[i] = (std::rand()/(float)RAND_MAX) * g->num_nodes; VertexSet* frontier = newVertexSet(SPARSE, numSources, g->num_nodes); for (int i = 0; i < numSources; i++) { addVertex(frontier, S[i]); } // iterate over values 1 thru k to do initialization VertexSet* ks = newVertexSet(SPARSE, numSources, g->num_nodes); for (int i = 0; i < numSources; i++) addVertex(ks, i); Init i(S, visited, nextVisited, radii); vertexMap(ks, i, NORETURN); freeVertexSet(ks); VertexSet *newFrontier; while (frontier->size > 0) { iter = iter + 1; RadiiUpdate ru(visited, nextVisited, radii, iter); newFrontier = edgeMap(g, frontier, ru); freeVertexSet(frontier); frontier = newFrontier; VisitedCopy vc(visited, nextVisited); vertexMap(frontier, vc, NORETURN); } for (int i = 0; i < g->num_nodes; i++) { free(visited[i]); free(nextVisited[i]); } freeVertexSet(frontier); free(visited); free(nextVisited); }
int main() { ru(5); rs(5); exit(0); }