TEST(VecOpr,Add_Sub){
	Vec A;
	Vec B;
	for(int i=0;i<10;i++){
		for(double c=-10;c<=10;c+=1){
			EXPECT_TRUE(((A)+(B)).size()==A.size());
			EXPECT_TRUE(((A)-(B)).size()==A.size());
		}
		A.push_back(Rand(engine));
		B.push_back(Rand(engine));
	}
	A.clear();
	B.clear();
	for(int i=0;i<10;i++){
		for(double c=-10;c<=10;c+=1){
			Vec C=(A)+(B);
			Vec D=(C)-(B);
			for(size_t i=0,n=A.size();i<n;i++){
				EXPECT_TRUE(D[i]==A[i]);
				EXPECT_TRUE(C[i]==(A[i]+B[i]));
			}
		}
		A.push_back(Rand(engine));
		B.push_back(Rand(engine));
	}
}
TEST(VecOpr,throwtest){
	Vec A;
	Vec B;
	for(int i=0;i<10;i++){
		A.push_back(Rand(engine));
		EXPECT_THROW((A)+(B),Exception<Vec>);
		EXPECT_THROW((A)-(B),Exception<Vec>);
		EXPECT_THROW(SqDistance((A),(B)),Exception<Vec>);
		EXPECT_THROW(Distance((A),(B)),Exception<Vec>);
		B.push_back(Rand(engine));
		EXPECT_NO_THROW((A)+(B));
		EXPECT_NO_THROW((A)-(B));
		EXPECT_NO_THROW(SqDistance((A),(B)));
		EXPECT_NO_THROW(Distance((A),(B)));
	}
	A.clear();B.clear();
	for(int i=0;i<10;i++){
		B.push_back(Rand(engine));
		EXPECT_THROW((A)+(B),Exception<Vec>);
		EXPECT_THROW((A)-(B),Exception<Vec>);
		A.push_back(Rand(engine));
		EXPECT_NO_THROW((A)+(B));
		EXPECT_NO_THROW((A)-(B));
	}
}
Esempio n. 3
0
void Lib::sortedUnique(int n, double *x, Vec& uv)
{
   uv.clear();
   if(n==0) return;
   typedef std::vector<double>::size_type vec_sz;

   //copy x into vector xv
   Vec xv(n);
   vec_sz nv = (vec_sz)n;
   for(vec_sz i=0;i<nv;i++) xv[i] = *(x+i);

   //sort xv
   std::sort(xv.begin(),xv.end());

   //get unique values of xv into uv
   uv.push_back(xv[0]);
   vec_sz nu = 1;
   double ov = uv[0];
   for(vec_sz i=1;i<nv;i++) {
      if(xv[i] != ov) {
         ov = xv[i];
         uv.push_back(ov);
      }
   }

}
Esempio n. 4
0
/*
 * This function tries to remove temporary variables in function `fn`
 *
 * A local variable is removed if:
 *
 * - It is def'd and use'd once
 *
 * - Its def is a PRIM_MOVE or PRIM_ASSIGN, with no possible
 *   communication
 * - RHS and LHS are of same type and non-extern
 *
 * - Its use is a suitable primitive
 * - Its use is not repeated(condition/increment statement of a loop)
 *
 * Denormalization uses helpers in util/exprAnalysis.cpp to decide if
 * it's safe to move function calls and primitives.
 */
void denormalize(void) {

  UseDefCastMap candidates;
  Vec<Symbol*> deferredSyms;
  SafeExprAnalysis analysisData;

  if(fDenormalize) {
    forv_Vec(FnSymbol, fn, gFnSymbols) {
      // remove unused epilogue labels
      removeUnnecessaryGotos(fn, true);

      bool isFirstRound = true;
      do {
        candidates.clear();
        deferredSyms.clear();

        // if we are analyzing locals in a function for the first time,
        // we look at all the symbols in the function. otherwise we only
        // look at the ones deferred in the previous passes on the same
        // function
        if(isFirstRound) {
          findCandidatesInFunc(fn, candidates, analysisData);
        }
        else {
          findCandidatesInFuncOnlySym(fn, deferredSyms, candidates,
              analysisData);
        }
        denormalizeOrDeferCandidates(candidates, deferredSyms);

        isFirstRound = false;
      } while(deferredSyms.count() > 0);
    }
  }
Esempio n. 5
0
int main(){
	int cases=0;
	while(1){
		int n,q;
		cin>>n>>q;
		if(n==0) break;
		++cases;
		cout<<"CASE# "<<cases<<":"<<endl;
		marble.clear();
		int k;
		for(int i=0;i<n;++i) {cin>>k;marble.push_back(k);}
		sort(marble.begin(),marble.end());
		for(int i=0;i<q;i++){
			cin>>k;
			Vec::iterator it=lower_bound(marble.begin(),marble.end(), k);
			if(it!=marble.end() && *it==k){
				cout<<k<<" found at "<<it-marble.begin()+1<<endl;
			}else{
				cout<<k<<" not found"<<endl;

			}
		}
	}
	return 0;	
}
Esempio n. 6
0
void Lib::acov(Vec& x,int nl, Vec& acov, bool cor)
{
        typedef Vec::size_type ST;
        double c;
        int n = (int)x.size();
        double m = mean(x);
        acov.clear();
        for(int i=0;i<=nl;i++)
        {
                c=0.0;
                for(int j=0;j<(n-i);j++) c += (x[j]-m)*(x[j+i]-m);
                acov.push_back(c);
        }
        if(cor)
        {
                double c0 = acov[0];
                for(int i=0;i<=nl;i++)
                {
                        acov[i] = acov[i]/c0;
                }
        }
        else
                for(int i=0;i<=nl;i++) acov[i] /= n;

}
Esempio n. 7
0
void alltoallPersonalized(Matpair &buf, int* parents,  Vec &nxFr, int size,const int &offset)
{
    //how many pairs will be collected from other rank
    nxFr.clear();
    int sendCount[size];
    int recCount[size];
    for (int i=0;i<size;i++){
        sendCount[i] = 0;
        recCount[i] = 0;
    }
    commCount(buf,sendCount,size);

    MPI_Barrier(MPI_COMM_WORLD);
    MPI_Alltoall(sendCount,1,MPI_INT,recCount,1, MPI_INT, MPI_COMM_WORLD);
    int sendDispl[size];
    int recDispl[size];
    scan(sendCount, sendDispl,size);
    scan(recCount,recDispl,size);

    int sendS = sendDispl[size-1]+sendCount[size-1];
    int recS = recDispl[size-1]+recCount[size-1];

    int sendPar[sendS],recPar[recS],sendNode[sendS],recNode[recS];
    vecpair2arrays(buf,sendPar,sendNode,size);
    MPI_Alltoallv(sendPar,sendCount,sendDispl,MPI_INT,recPar,recCount,recDispl,MPI_INT,MPI_COMM_WORLD);
    MPI_Alltoallv(sendNode,sendCount,sendDispl,MPI_INT,recNode,recCount,recDispl,MPI_INT,MPI_COMM_WORLD);

    nextFr(recPar,recNode,recS,offset,parents,nxFr);

}
Esempio n. 8
0
static void Move_AutoGrownMemIO_to_valvec(AutoGrownMemIO& io, Vec& v) {
	BOOST_STATIC_ASSERT(sizeof(typename Vec::value_type) == 1);
	BOOST_STATIC_ASSERT(sizeof(v[0]) == 1);
	v.clear();
	v.risk_set_size(io.tell());
	v.risk_set_data((typename Vec::value_type*)io.buf());
	v.risk_set_capacity(io.size());
	io.risk_release_ownership();
}
TEST(VecOpr,Distances){
	Vec A;
	Vec B;
	for(int i=0;i<10;i++){
		for(double c=-10;c<=10;c+=1){
			double d=Distance((A),(B));
			EXPECT_TRUE(d>=0);
			EXPECT_TRUE(sqrt(SqDistance((A),(B)))==d);
		}
		A.push_back(Rand(engine));
		B.push_back(Rand(engine));
	}
	A.clear();
	B.clear();
	A.push_back(Rand(engine));
	B.push_back(Rand(engine));
	EXPECT_TRUE(SqDistance((A),(B))==pow(A[0]-B[0],2));
}
Esempio n. 10
0
int main(){
	int kase =0;
	while(true){
		int c,s,q;
		cin>>c>>s>>q;
		if (c==0) break;
		++kase;
		edges.clear();
		for(int i=0;i<s;++i){
			Edge e;
			cin>>e.from>>e.to>>e.weight;
			edges.push_back(e);
		}
		sort(edges.begin(), edges.end());
		for(int i=1;i<=c;++i){
			nodes[i].parent = nodes+i;
			nodes[i].count = 0;
			nodes[i].edges.clear();
		}
		int count =0;
		for(Vec::iterator it = edges.begin(); count< c-1 && it!= edges.end(); ++it){
			Node *rs = getRoot(it->from), *rt = getRoot(it->to);
			if(rs == rt) continue;
			if (rs->count > rt->count){
				rt->parent = rs;
				rs->count+=rt->count;
			} else {
				rs->parent = rt;
				rt->count += rs->count;
			}
			++count;

			nodes[it->from].edges.push_back(*it);
			int tmp = it->to;
			it->to = it->from; it->from =tmp;
			nodes[it->from].edges.push_back(*it);
		}
		if (kase >1) cout<<endl;
		cout<<"Case #"<<kase<<endl;
		for(int i=0;i<q; ++i){
			int s,t;
			cin>>s>>t;
			CalcResult result = calc(s,t,0);
			if (result.reached) {
				cout<<result.value<<endl;
			} else {
				cout<<"no path"<<endl;
			}
		}
	}
	return 0;
}
Esempio n. 11
0
void Lib::batchMeans(Vec& x, int bsize, Vec& means)
{
        means.clear();
        int n = (int)x.size();
        bool someleft = (n>=bsize);
        int nbatch=0;
        while(someleft)
        {
                double sum = 0.0;
                int off = nbatch*bsize;
                for(int i=0;i<bsize;i++) sum += x[off+i];
                means.push_back(sum/bsize);
                nbatch += 1;
                someleft = (n>=(bsize)*(nbatch+1));
        }
}
Esempio n. 12
0
void TestTransform()
{
  typedef vector<int> Vec;
  Vec test1;
  Vec checked1;
  Vec checked;
  for(int i = 1; i < 5; i++) 
  {
	test1.push_back (i * i);                    // test1: 1 4 9  16 
	checked1.push_back (i * i);
  }

  //vector<int> test2(test1.size());
  //transform(test1.begin(), test1.end(), test2.begin(), [](int i){return ++i;});       // test2: 2 5 10 17

  Vec test2p;
  transform(test1.begin(), test1.end(), back_inserter(test2p), [](int i){return ++i;});       // test2: 2 5 10 17


  cout << "Unary operation, the first is the same: ";
  checked.push_back(2);
  checked.push_back(5);
  checked.push_back(10);
  checked.push_back(17);
  CHECK_RESULTS(IsEqual(test1, checked1));
  cout << "Unary operation, the second has changed: ";
  CHECK_RESULTS(IsEqual(test2p, checked));

  cout << "Binary operation, the first is the same: ";
  checked.clear();
  checked.push_back(3);
  checked.push_back(9);
  checked.push_back(19);
  checked.push_back(33);
  transform(test1.begin(), test1.end(), test2p.begin(), test2p.begin(), [](int i, int j){return i + j;}); // test1: 3 9 19 33 
  CHECK_RESULTS(IsEqual(test1, checked1));   
  cout << "Binary operation, the second has changed: ";
  CHECK_RESULTS(IsEqual(test2p, checked));

  cout << "No elements: ";
  test1.erase(test1.begin(), test1.end());
  checked.erase(checked.begin(), checked.end());
  test2p.erase(test2p.begin(), test2p.end());
  transform(test1.begin(), test1.end(), back_inserter(test2p),[](int i){return ++i;});
  CHECK_RESULTS(IsEqual(test2p, checked));
 }
TEST(VecOpr,Mul){
	Vec A;
	for(int i=0;i<10;i++){
		for(double c=-10;c<=10;c+=1)
			EXPECT_TRUE(((A)*c).size()==A.size());
		A.push_back(Rand(engine));
	}
	A.clear();
	for(int i=0;i<10;i++){
		for(double c=-9.5;c<10;c+=1){//escape zero
			Vec B=(A)*c;
			Vec C=(B)*(1.0/c);
			for(size_t i=0,n=A.size();i<n;i++){
				EXPECT_TRUE(C[i]==A[i]);
				EXPECT_TRUE(B[i]==(A[i]*c));
			}
		}
		A.push_back(iRand(engine));
	}
}
Esempio n. 14
0
File: 120.cpp Progetto: liuhb86/uva
int main() {
    string s;
    while(getline(cin,s)) {
        cout<<s<<endl;
        istringstream iss(s);
        pancake.clear();
        int k;
        while(iss>>k) {
            pancake.push_back(k);
        }
        Vec dest(pancake);
        sort(dest.begin(),dest.end());
        for(int i=pancake.size()-1; i>=0; i--) {
            if(pancake[i]==dest[i]) continue;
            int j;
            for(j=0; j<i; j++) if(pancake[j]==dest[i]) break;
            if(j!=0) flip(j);
            flip(i);
        }
        cout<<'0'<<endl;
    }
    return 0;
}
	virtual void AcceptEventStart()override{times.clear();}
Esempio n. 16
0
 void clear() { path_length_valid = false; vec.clear(); }
Esempio n. 17
0
void init(){
    vw.clear(); vw.resize(N);
    pf.clear(); pf.resize(N);
    vf.clear(); vf.resize(N);
    th.clear(); th.resize(N);
}
Esempio n. 18
0
 void clear() {
     v1.clear();
     v2.clear();
 }