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