//------------------------------------------------------------------------------------- void EntityCoordinateNode::entitiesInRange(std::vector<Entity*>& foundEntities, CoordinateNode* rootNode, const Position3D& originPos, float radius, int entityUType) { std::set<Entity*> entities_X; std::set<Entity*> entities_Z; entitiesInAxisRange<CoordinateNodeWrapX>(entities_X, rootNode, originPos, radius, entityUType); entitiesInAxisRange<CoordinateNodeWrapZ>(entities_Z, rootNode, originPos, radius, entityUType); // 查找Y if (CoordinateSystem::hasY) { std::set<Entity*> entities_Y; entitiesInAxisRange<CoordinateNodeWrapY>(entities_Y, rootNode, originPos, radius, entityUType); std::set<Entity*> res_set; set_intersection(entities_X.begin(), entities_X.end(), entities_Z.begin(), entities_Z.end(), std::inserter(res_set, res_set.end())); set_intersection(res_set.begin(), res_set.end(), entities_Y.begin(), entities_Y.end(), std::back_inserter(foundEntities)); } else { set_intersection(entities_X.begin(), entities_X.end(), entities_Z.begin(), entities_Z.end(), std::back_inserter(foundEntities)); } }
/** Procédure récursive pour trouver les cliques du graphe (Algorithme de Bron-Kerbosch).*/ void OperateurEnsemble::bk_recursive(setNoeud combination, setNoeud intersection, setNoeud possible, vector<setNoeud>* res) { /*cout<<"Current :"; for(setNoeud::iterator it = combination.begin();it!=combination.end();it++) cout<<(*it)->nom_parser<<" "; cout<<endl; cout<<"Possible :"; for(setNoeud::iterator it = possible.begin();it!=possible.end();it++) cout<<(*it)->nom_parser<<" "; cout<<endl; cout<<"Intersection :"; for(setNoeud::iterator it = intersection.begin();it!=intersection.end();it++) cout<<(*it)->nom_parser<<" "; cout<<endl<<endl;*/ if(intersection.empty()) //plus rien à ajouter, on a trouvé une clique { res->push_back(combination); return; } setNoeud S = possible; for(setNoeud::iterator it = S.begin(); it!=S.end(); it++) //pour chaque noeud à traiter { possible.erase(*it); //on supprime l'élément sélectionné des candidats setNoeud new_inter; set_intersection(intersection.begin(),intersection.end(),succ[*it].begin(),succ[*it].end(),inserter(new_inter,new_inter.begin())); //intersection avec les voisins du noeud sélectionné setNoeud new_possible; set_intersection(possible.begin(),possible.end(),succ[*it].begin(),succ[*it].end(),inserter(new_possible,new_possible.begin())); //intersection avec les voisins du noeud sélectionné setNoeud new_comb = combination; new_comb.insert(*it); bk_recursive(new_comb,new_inter,new_possible,res); } }
void bron_kerbosch(set <int> R, set <int> P, set <int> X) { // where R is probable clique, P - possible vertices in clique, X - exluded vertices if (P.size() == 0 && X.size() == 0) { // R is maximal clique cliques.push_back(vector<int>(0)); for (set<int>::iterator i = R.begin(); i != R.end(); i++) { cliques.back().push_back(*i); } } else { set <int> foriterate = P; for (set<int>::iterator i = foriterate.begin(); i != foriterate.end(); i++) { set <int> newR; set <int> newP; set <int> newX; newR = R; newR.insert(*i); set_intersection(P.begin(), P.end(), edge[*i].begin(), edge[*i].end(), inserter(newP, newP.begin())); set_intersection(X.begin(), X.end(), edge[*i].begin(), edge[*i].end(), inserter(newX, newX.begin())); bron_kerbosch(newR, newP, newX); P.erase(*i); X.insert(*i); } } }
void castGWAS::interSect(castSNP &SNPs) { set<string> tmp; set_intersection(initial_keys.begin(), initial_keys.end(), SNPs.onChip.begin(), SNPs.onChip.end(), inserter(tmp, tmp.end())); semifinishedKeys.clear(); set_intersection(tmp.begin(), tmp.end(), SNPs.onHapMap.begin(), SNPs.onHapMap.end(), inserter(semifinishedKeys, semifinishedKeys.end())); }
void test_set_intersection (void) { int numbers1[] = {1, 2, 3, 4, 5, 6, 7}; int numbers2[] = {5, 6, 7, 8, 9, 10, 11}; int result[] = {5, 6, 7}; int i; Set* set1; Set* set2; Set* result_set; size_t allocated; /* Create the first set */ set1 = set_new (int_hash, int_equal); for (i = 0; i < 7; ++i) { set_insert (set1, &numbers1[i]); } /* Create the second set */ set2 = set_new (int_hash, int_equal); for (i = 0; i < 7; ++i) { set_insert (set2, &numbers2[i]); } /* Perform the intersection */ result_set = set_intersection (set1, set2); assert (set_num_entries (result_set) == 3); for (i = 0; i < 3; ++i) { assert (set_query (result_set, &result[i]) != 0); } /* Test out of memory scenario */ alloc_test_set_limit (0); assert (set_intersection (set1, set2) == NULL); /* Can allocate set, can't copy all values */ alloc_test_set_limit (2 + 2); allocated = alloc_test_get_allocated(); assert (set_intersection (set1, set2) == NULL); assert (alloc_test_get_allocated() == allocated); set_free (set1); set_free (set2); set_free (result_set); }
void CityFinder::findNearbyCities(double radius) { set<string> citySetRes, citySetInters, citySet1, citySet2; double latLowBound = centerCity.second.lat - radius; double latUpperBound = centerCity.second.lat + radius; for (auto it = latLookup.lower_bound(latLowBound); it != latLookup.upper_bound(latUpperBound); ++it) { citySet1.insert(latLookup[it->first]); } double lonLowBound = centerCity.second.lon - radius; double lonUpperBound = centerCity.second.lon + radius; for (auto it = lonLookup.lower_bound(lonLowBound); it != lonLookup.upper_bound(lonUpperBound); ++it) { citySet2.insert(lonLookup[it->first]); } set_intersection(citySet1.begin(), citySet1.end(), citySet2.begin(), citySet2.end(), inserter(citySetInters, citySetInters.end())); for (string cityName : citySetInters) { City city = make_pair(cityName, cityLookup.find(cityName)->second); if (distance(city) <= radius) { citySetRes.insert(cityName); } } for (string cityName : citySetRes) { cout << cityName << endl; } }
std::pair<CombSet::iterator,bool> ReqS_LACP::operator() ( std::list<CombSet::iterator> &local_state_cache, std::set<int> &dealed_factors, const Requirement &req) { float min_num=m_max_number; std::list<CombSet::iterator>::iterator selected_it1=local_state_cache.begin(); std::list<CombSet::iterator>::iterator selected_it2=local_state_cache.end(); for(std::list<CombSet::iterator>::iterator it=local_state_cache.begin(); it!=local_state_cache.end();++it) { const std::set<int> &inter=(*it)->getParaSet(); std::vector<int> temp(dealed_factors.size()+inter.size(),-1); std::vector<int>::iterator the_end=set_intersection( dealed_factors.begin(),dealed_factors.end(), inter.begin(),inter.end(),temp.begin()); int num=1; for(std::vector<int>::const_iterator itp=temp.begin();itp!=the_end;++itp) num*=req.getParaValue(*itp); float number=((float)(num))/((float)((*it)->Size())); if(number<min_num && num>1) { min_num=number; selected_it2=it; } } CombSet::iterator selected_one; bool flag=ModifyLocalStateCache(selected_it1,selected_it2, local_state_cache,dealed_factors,selected_one); return std::pair<CombSet::iterator,bool>(selected_one,flag); }
double mirkin_distance(const cluster_list& c1, const cluster_list& c2) { size_t c1_sum2 = 0; size_t n = 0; for (size_t i=0; i < c1.size(); i++) { c1_sum2 += c1[i].size() * c1[i].size(); n += c1[i].size(); } size_t c2_sum2 = 0; for (size_t i=0; i < c2.size(); i++) { c2_sum2 += c2[i].size() * c2[i].size(); } size_t c1c2_sum2 = 0; for (size_t i=0; i < c1.size(); i++) { for (size_t j=0; j < c2.size(); j++) { size_t size; set_intersection(c1[i].begin(), c1[i].end(), c2[j].begin(), c2[j].end(), counter(size)); c1c2_sum2 += size * size; } } return (c1_sum2 + c2_sum2 - (2 * c1c2_sum2)) / (double)(n*n); }
int main(void) { set s1, s2; int m = 10; s1 = set_init(m); set_add(s1, 1); set_add(s1, 3); set_add(s1, 5); s2 = set_init(m + 2); set_add(s2, 0); set_add(s2, 2); set_add(s2, 3); set_add(s2, 4); set_add(s2, 5); set_add(s2, 11); set_print(s1); printf("\n"); set_print(s2); printf("\nIntersection: "); set_print(set_intersection(s1, s2)); printf("\nUnion: "); set_print(set_union(s1, s2)); printf("\nComplement for s2: "); set_print(set_complement(s2)); printf("\n"); return 0; }
void distinct_keys(std::vector<std::unordered_set<key_type> >& key_assignments, std::unordered_set<key_type>& result) { std::unordered_set<key_type> I, U; set_intersection(key_assignments, I); set_union(key_assignments, U); set_difference(U, I, result); }
/* This api takes the user input - and looks up the word[s] in the inverted index. The candidate documents are then ranked based on tf-idf BOW (bag of words) model */ std::vector<std::pair<int,double> > ServeIndex(const std::string& word,int topK) { //tokenize and normalize the user text std::vector<std::string>& word_tokens = _wordBreaker->BreakEnglishText(word.c_str()); std::vector<std::pair<int,double> > results; //generate the candidate document set std::set<int> candSet; bool foundAny = false; for(size_t i=0;i<word_tokens.size();++i) { boost::unordered_map<std::string,IndexEntry>::iterator itor = _indexPtr->_wordIndex.find(word_tokens[i]); if( itor == _indexPtr->_wordIndex.end() ) continue; else{ //first entry which was found if(!foundAny){ candSet = itor->second._docSet; foundAny = true; } else{ std::set<int> temp; set_intersection(candSet.begin(),candSet.end(),(itor->second)._docSet.begin(),(itor->second)._docSet.end(),inserter(temp,temp.begin())); candSet.clear(); candSet = temp; } } } return Rank(word_tokens,candSet,topK); }
void test_set_operations(){ set_t *even1 = new_set(10); set_t *even2 = new_set(10); set_t *odd = new_set(10); int i; for (i=0; i < 10; i++){ set_put(even1, 2*i); set_put(even2, 2*i); set_put(odd, 2*i+1); } set_union(even1, odd); assert(set_size(even1) == 20); set_difference(even2, odd); assert(set_size(even2) == 10); set_intersection(even2, odd); assert(set_size(even2) == 0); set_print(even1); printf("\n"); set_optimize(even1); set_print(even1); printf("\n"); set_print(even2); printf("\n"); set_print(odd); printf("\n"); delete_set(even1); delete_set(even2); delete_set(odd); }
QueryResult AndQuery::eval(const TextQuery& text) const { auto left=lhs.eval(text), right=rhs.eval(text); auto ret_lines=std::make_shared<std::set<line_no>>(); set_intersection(left.begin(),left.end(),right.begin(),right.end(),inserter(*ret_lines,ret_lines->begin())); return QueryResult(rep(),ret_lines,left.get_file()); }
vector<int> intersect(vector<int>& nums1, vector<int>& nums2) { vector<int> v; sort(nums1.begin(),nums1.end()); sort(nums2.begin(),nums2.end()); set_intersection(nums1.begin(),nums1.end(),nums2.begin(),nums2.end(),inserter(v,v.end())); return v; }
void date_intersection(const CONT<TSeries<TDATE,TDATA,TSDIM,TSDATABACKEND,DatePolicy> >& cont, II output_dates) { std::vector<TDATE> inBuff; std::vector<TDATE> outBuff; typename CONT<TSeries<TDATE,TDATA,TSDIM,TSDATABACKEND,DatePolicy> >::const_iterator it = cont.begin(); // pre-load dates for first series std::copy(it->getDates(),it->getDates() + it->nrow(), std::inserter(inBuff,inBuff.begin())); for(it = cont.begin() + 1; it != cont.end(); it++) { outBuff.clear(); set_intersection(inBuff.begin(),inBuff.end(), it->getDates(),it->getDates() + it->nrow(), std::inserter(outBuff,outBuff.begin())); // swap buffs inBuff.clear(); std::copy(outBuff.begin(),outBuff.end(), std::inserter(inBuff,inBuff.begin())); } std::copy(outBuff.begin(),outBuff.end(),output_dates); }
bool xRedisClient::sinter(const DBIArray& vdbi, const KEYS& vkey, VALUES& sValue) { int size = vkey.size(); VALUES *setData = new VALUES[size]; VALUES::iterator endpos; DBIArray::const_iterator iter_dbi = vdbi.begin(); KEYS::const_iterator iter_key = vkey.begin(); int i=0; for (; iter_key!=vkey.end(); ++iter_key, ++iter_dbi, ++i) { const string &key = *iter_key; const RedisDBIdx &dbi = *iter_dbi; if (!smember(dbi, key, setData[i])) { delete [] setData; return false; } } int n=0; while(n++<size-1) { endpos = set_intersection( setData[n].begin(), setData[n].end(), setData[n+1].begin(), setData[n+1].end() , sValue.begin()); sValue.resize( endpos - sValue.begin()); } delete [] setData; return true; }
/** * Find all maximal cliques in an induced subgraph of some chain component * * NOTE: the function does not check whether the provided range of vertices * really is a subset of some chain component! */ template <typename InputIterator> std::vector<std::set<uint> > getMaxCliques(InputIterator first, InputIterator last) { std::vector<std::set<uint> > maxCliques; // Trivial case: range of vertices contains at most one vertex if (std::distance(first, last) <= 1) { maxCliques.push_back(std::set<uint>(first, last)); return maxCliques; } // For less trivial cases, first generate a LexBFS-ordering on the provided range of vertices std::vector<uint> ordering = lexBFS(first, last); // Find maximal cliques using the LexBFS-ordering std::set<uint> nbhdSubset(first, last); std::set<uint> vertices, C; std::vector<std::set<uint> >::iterator cliqueIter; bool included; for (int i = ordering.size() - 1; i >= 0; --i) { nbhdSubset.erase(ordering[i]); vertices = getNeighbors(ordering[i]); C = set_intersection(vertices, nbhdSubset); C.insert(ordering[i]); included = false; for (cliqueIter = maxCliques.begin(); !included && cliqueIter != maxCliques.end(); ++cliqueIter) included = std::includes(cliqueIter->begin(), cliqueIter->end(), C.begin(), C.end()); if (!included) maxCliques.push_back(C); } return maxCliques; }
mixed *set_difference(mixed *a, mixed *b, varargs int r) { mixed *c; c = set_intersection(a, set_symmetric_difference(a, b)); return r ? set_remove_repeats(c) : c; }
int RACScore::GetMultiLevelCommNeighbors( const BglVertex& u, const BglVertex& v, vector<int>& vecCommNeighbors, const int level) { vector<int> vecUNeighbor; vector<int> vecVNeighbor; int initial = 0; BFS(u, vecUNeighbor, initial, level); BFS(v, vecVNeighbor, initial, level); sort(vecUNeighbor.begin(), vecUNeighbor.end()); sort(vecVNeighbor.begin(), vecVNeighbor.end()); int maxSize = vecUNeighbor.size() > vecVNeighbor.size()? vecUNeighbor.size():vecVNeighbor.size(); vector<int> myVecCommNeighbors(maxSize); myVecCommNeighbors.resize(maxSize); vector<int>::iterator it_end; it_end = set_intersection(vecUNeighbor.begin(), vecUNeighbor.end(), vecVNeighbor.begin(), vecVNeighbor.end(), myVecCommNeighbors.begin()); //cout << vecUNeighbor.size() << ' ' << vecVNeighbor.size() <<' ' << maxSize <<' ' << distance(myVecCommNeighbors.begin(),it_end) <<endl; vecCommNeighbors.resize(distance(myVecCommNeighbors.begin(), it_end)); copy(myVecCommNeighbors.begin(), it_end ,vecCommNeighbors.begin()); return distance(myVecCommNeighbors.begin(),it_end) ; }
void Server::handleInvolvedByMinIds() { // read input data size_t tp_hash_count = recvLong(); std::vector<GitOid> tp_hashes; for (size_t i = 0; i < tp_hash_count; ++i) { tp_hashes.push_back(recvOid()); } std::vector<int> min_ids = getMinIds(recvLongVector()); // process request sort(min_ids.begin(), min_ids.end()); // TODO: sort tp_hashes by first_id (to optimize reads from mapped file), remember indices before sorting! std::vector<int> res; for (size_t i = 0; i < tp_hashes.size(); ++i) { std::vector<int> c_ids = getTphashMinIds(tp_hashes[i]); sort(c_ids.begin(), c_ids.end()); std::vector<int> intersection(min_ids.size()); if (set_intersection( min_ids.begin(), min_ids.end(), c_ids.begin(), c_ids.end(), intersection.begin()) != intersection.begin()) { res.push_back(i); } } // write output data sendLongVector(res); }
bool * Hypergraph::selectLinkage() { vector<int> result (_nVertices); vector<int>::iterator resultPos = result.begin(); for (int i=0; i<_linkageBuf.size(); ++i) { const HyperEdge & e = _edges[_linkageBuf[i]-_nVertices]; if (i==0) { copy(e.begin(), e.end(), result.begin()); advance(resultPos, e.size()); } else { resultPos = set_intersection(e.begin(), e.end(), result.begin(), resultPos, result.begin()); } } bool *selectionBuf = new bool [_nVertices]; memset(selectionBuf, false, _nVertices*sizeof(bool)); for (vector<int>::iterator it=result.begin(); it!=resultPos; ++it) { selectionBuf[*it] = true; } _linkageBuf.clear(); return selectionBuf; }
double mutual(deque<deque<int>> en, deque<deque<int>> ten) { // en e ten are two partitions of integer numbers int dim; { set<int> conta; for (int i = 0; i < ten.size(); i++) { sort(ten[i].begin(), ten[i].end()); for (int j = 0; j < ten[i].size(); j++) { conta.insert(ten[i][j]); //ten_.insert(ten[i][j]); } } for (int i = 0; i < en.size(); i++) { sort(en[i].begin(), en[i].end()); for (int j = 0; j < en[i].size(); j++) { conta.insert(en[i][j]); //en_.insert(en[i][j]); } } dim = conta.size(); } deque<deque<double>> N; deque<double> first; first.assign(en.size(), 0); for (int i = 0; i < ten.size(); i++) N.push_back(first); deque<int> s(dim); for (int i = 0; i < ten.size(); i++) for (int j = 0; j < en.size(); j++) N[i][j] = set_intersection(ten[i].begin(), ten[i].end(), en[j].begin(), en[j].end(), s.begin()) - s.begin(); deque<double> NR; NR.assign(ten.size(), 0); deque<double> NC; NC.assign(en.size(), 0); double NTOT = dim; for (int i = 0; i < ten.size(); i++) for (int j = 0; j < en.size(); j++) { NR[i] += N[i][j]; NC[j] += N[i][j]; } double IN = 0; double ID1 = 0; double ID2 = 0; for (int i = 0; i < ten.size(); i++) for (int j = 0; j < en.size(); j++) if (N[i][j] != 0) IN += N[i][j] * log(N[i][j] * NTOT / (NR[i] * NC[j])); IN = -2. * IN; for (int i = 0; i < ten.size(); i++) if (NR[i] != 0) ID1 += NR[i] * log(NR[i] / (NTOT)); for (int j = 0; j < en.size(); j++) if (NC[j] != 0) ID2 += NC[j] * log(NC[j] / (NTOT)); double I = IN / (ID1 + ID2); if ((ID1 + ID2) == 0) I = -2; return I; }
void AlignmentElement::SetIntersect(const AlignmentElement &otherElement) { ContainerType newElement; set_intersection(m_collection.begin() , m_collection.end() ,otherElement.begin() , otherElement.end() ,inserter(newElement , newElement.begin()) ); m_collection = newElement; }
bool Diff::compare(string exclude) { RegExp exc; if (!exclude.empty()) { exc.setExpr(exclude); } bool same = true; FileWalker fw; vector<string> files1; fw.walk(file1, [&] (const File& f) { if (f.getType() == File::FileType::DIRECTORY) { return; } if (!exclude.empty() && exc.matches(f.getName())) { return; } string relPart = f.getPath().substr(file1.getPath().size()); files1.push_back(relPart); }); sort(files1.begin(),files1.end()); vector<string> files2; fw.walk(file2, [&] (const File& f) { if (f.getType() == File::FileType::DIRECTORY) { return; } if (!exclude.empty() && exc.matches(f.getName())) { return; } string relPart = f.getPath().substr(file2.getPath().size()); files2.push_back(relPart); }); sort(files2.begin(),files2.end()); vector<string> intersected; set_intersection(files1.begin(),files1.end(),files2.begin(), files2.end(),back_inserter(intersected)); for (auto f:intersected) { string f1 = file1.getPath() + f; string f2 = file2.getPath() + f; string cmd = "cmp -s '" + f1 + "' '" + f2 + "'"; int exitCode = system(cmd.c_str()); if (exitCode != 0) { cout << "meld " << f1 << " " << f2 << endl; same =false; } } vector<string> only1; set_difference(files1.begin(),files1.end(),files2.begin(), files2.end(),back_inserter(only1)); for (auto f:only1) { cout << "only in " << file1.getPath() << ": " << f << endl; same = false; } vector<string> only2; set_difference(files2.begin(),files2.end(),files1.begin(), files1.end(),back_inserter(only2)); for (auto f:only2) { cout << "only in " << file2.getPath() << ": " << f << endl; same = false; } return same; }
void testSet_2() { vector<vector<int>> sets(SETNUM); int n = dataGen_2(sets); int* ret = new int[n]; #ifdef TIMING_FOR_APLWAH clock_t t1,t2; t1 = clock(); #endif #ifdef NUM_LIST for(int i=0;i<SETNUM;i++){ printf("\nSet %d:",i); for(int j=0;j<NUM_LIST;j++){ printf(" %d",sets[i][j]); } } printf("\n\n"); #endif int* end = set_intersection(sets[0].begin(),sets[0].end(),sets[1].begin(),sets[1].end(),ret); for(int i=2;i<SETNUM;i++){ end = set_intersection(ret,end,sets[i].begin(),sets[i].end(),ret); } #ifdef NUM_LIST printf("Intersections:"); for(int j=0;j<NUM_LIST;j++){ printf(" %d",ret[j]); } printf("\n\n"); #endif #ifdef TIMING_FOR_APLWAH t2 = clock(); printf("STL set_intersection:\n%d Sets, each with %d integers, Step %d\nResult: %d integers, using %d ms\n\n",SETNUM,INTNUM,STEP,end - ret,t2 - t1); #endif #ifdef COUNTING int* start = ret; while(start != end){ cout<<*start<<' '; start++; } cout<<endl; #endif }
static void flow_uninit_scan_statements (flownode_t *node, set_t *defs, set_t *uninit) { set_t *stuse; set_t *stdef; statement_t *st; set_iter_t *var_i; flowvar_t *var; operand_t *op; // defs holds only reaching definitions. make it hold only reaching // uninitialized definitions set_intersection (defs, uninit); stuse = set_new (); stdef = set_new (); for (st = node->sblock->statements; st; st = st->next) { flow_analyze_statement (st, stuse, stdef, 0, 0); for (var_i = set_first (stuse); var_i; var_i = set_next (var_i)) { var = node->graph->func->vars[var_i->element]; if (set_is_intersecting (defs, var->define)) { def_t *def = flowvar_get_def (var); if (def) { if (options.warnings.uninited_variable) { warning (st->expr, "%s may be used uninitialized", def->name); } } else { bug (st->expr, "st %d, uninitialized temp %s", st->number, operand_string (var->op)); } } // avoid repeat warnings in this node set_difference (defs, var->define); } for (var_i = set_first (stdef); var_i; var_i = set_next (var_i)) { var = node->graph->func->vars[var_i->element]; // kill any reaching uninitialized definitions for this variable set_difference (defs, var->define); if (var->op->op_type == op_temp) { op = var->op; if (op->o.tempop.alias) { var = op->o.tempop.alias->o.tempop.flowvar; if (var) set_difference (defs, var->define); } for (op = op->o.tempop.alias_ops; op; op = op->next) { var = op->o.tempop.flowvar; if (var) set_difference (defs, var->define); } } } } set_delete (stuse); set_delete (stdef); }
int main() { int N = 1000; set_t a, b, c, r; for (N = 100; N < 1000000; N += 2000) { int milli = 0; // add code to start timing struct timeval startTime; struct timeval endTime; long startMillis; long endMillis; gettimeofday(&startTime, NULL); startMillis = startTime.tv_sec * MILLIS_PER_SECOND + startTime.tv_usec / 1000 ; set_init(&a, N); set_init(&b, N); set_init(&c, N) ; set_init(&r, N) ; for (int i = 0; i < N; i++) if ((i % 2) == 0) set_add_elem(&a, i); for (int i = 0; i < N; i++) if ((i % 2) == 1) set_add_elem(&b, i); set_union(&a, &b, &a); set_intersection(&b, &c, &b); for (int i = 0; i < N; i++) if ((i % 2) == 0) set_add_elem(&b, i); for (int i = 0; i < N; i++) if ((i % 4) == 0) set_add_elem(&c, i); set_intersection(&a, &b, &r); set_intersection(&r, &c, &r); // add code to stop timing and compute the run-time in milliseconds // in variable milli // gettimeofday(&endTime, NULL); endMillis = endTime.tv_sec * MILLIS_PER_SECOND + endTime.tv_usec / 1000 ; milli = (int) (endMillis - startMillis); printf("%d\t%d\n", N, milli); } return 0; }
double measure(set<string>& genes_collection1,set<string>& genes_collection2,DictStringSet& sample_mutatedGenes) { int out1; int inside1; int out2; int inside2; set<string> genes_in_sample; set<string> inside_genes1; set<string> inside_genes2; int num_ig1; int num_ig2; //coverage of genes in genes_collection1 out1 = 0; //total number of mutations in genes_collection1 inside1 = 0; //coverage of genes_collection2 out2 = 0; //total number of mutations in genes_collection2 inside2 = 0; tr(sample_mutatedGenes,it) { //it->first is the sampleID genes_in_sample = sample_mutatedGenes[it->first]; set_intersection(all(genes_collection1),all(genes_in_sample),inserter(inside_genes1,inside_genes1.end())); if(inside_genes1.size() > 0) out1 += 1; num_ig1 = (int)inside_genes1.size(); inside1 += num_ig1; set_intersection(all(genes_collection2),all(genes_in_sample),inserter(inside_genes2,inside_genes2.end())); if(inside_genes2.size() > 0) out2 += 1; num_ig2 = inside_genes2.size(); inside2 += num_ig2; }
void VACExtension::updateSingleton() { set < int >&s1 = singleton; set < int >s2(singletonI); singletonI.clear(); set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(), inserter(singletonI, singletonI.begin())); singleton.clear(); }
Set<V> Intersection(const Set<V>& s1, const Set<V>& s2) { set<V> myintersect; set<V>::iterator i = myintersect.begin(); insert_iterator<set<V> > insertiter(myintersect, i); set_intersection(s1.s.begin(), s1.s.end(), s2.s.begin(), s2.s.end(), insertiter); return Set<V>(myintersect); }