C++ Vec::push_back方法代码示例

TEST(CollectionUtilsTest, vecShiftLeftByMoreThanSize) {
    typedef std::vector<size_t> Vec;
    Vec vec;
    
    vec.push_back('a');
    vec.push_back('b');
    vec.push_back('c');
    vec.push_back('d');
    vec.push_back('e');
    vec.push_back('f');
    vec.push_back('g');
    
    Vec leftBy10;
    leftBy10.push_back('d');
    leftBy10.push_back('e');
    leftBy10.push_back('f');
    leftBy10.push_back('g');
    leftBy10.push_back('a');
    leftBy10.push_back('b');
    leftBy10.push_back('c');

    Vec actual = vec;
    VectorUtils::shiftLeft(actual, 10);
    ASSERT_TRUE(std::equal(leftBy10.begin(), leftBy10.end(), actual.begin()));
}

Vec ASSR::initial_state_mean()const {
    Vec ans = StateSpaceModelBase::initial_state_mean();
    double y0 = StateSpaceModelBase::observation_matrix(0).dot(ans);
    ans.push_back(y0);
    ans.push_back(0.0);
    return ans;
}

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

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

}

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;

}

int main(int argc, const char *argv[])
{
    Vec<Student_info> students;
    Student_info record;
    string::size_type maxlen = 0;

    while (record.read(cin)) {
        maxlen = max(maxlen, record.name().size());
        students.push_back(record);
    }

    //  
    sort(students.begin(), students.end(), compare);

    for (Vec<double>::size_type i = 0; i != students.size(); i++) {
        cout << students[i].name() << string(maxlen + 1 - students[i].name().size(), ' ');
        try {
            double final_grade = students[i].grade();
            streamsize prec = cout.precision();
            cout << setprecision(3) << final_grade << setprecision(prec) << endl;
        } catch (domain_error e) {
            cout << e.what() << endl;
        }
    }
    return 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;	
}

 Vec ArModel::simulate(int n, const Vec &y0) const {
   if(y0.size() != number_of_lags()){
     ostringstream err;
     err << "Error in ArModel::simulate." << endl
         << "Initial state value y0 was size " << y0.size()
         << ", but the model has " << number_of_lags() << " lags."
         << endl;
     report_error(err.str());
   }
   const Vec &phi(this->phi());
   std::deque<double> lags(y0.rbegin(), y0.rend());
   Vec ans;
   ans.reserve(n);
   for(int i = 0; i < n; ++i) {
     double mu = 0;
     for(int lag = 0; lag < number_of_lags(); ++lag) {
       mu += phi[lag] * lags[lag];
     }
     double y = rnorm(mu, sigma());
     lags.push_front(y);
     lags.pop_back();
     ans.push_back(y);
   }
   return ans;
 }

int main()
{
    int H, W, x;
    while (cin >> H >> W, H) {
        Vec subT;
        for (int i = 0; i < H; i++) {
            for (int j = 0; j < W; j++) {
                cin >> x;  
                if (x == 1) {
                    subT.push_back(i * W + j);
                }
            }
        }

        Graph G(H * W, Vec(H * W));
        for (int i = 0; i < H; i++) {
            for (int j = 0; j < W; j++) {
                for (int k = 0; k < H; k++) {
                    for (int l = 0; l < W; l++) {
                        G[i * W + j][k * W + l] = get_dist(i, j, k, l);
                    }
                }
            }
        }
        cout << H * W - minimum_steiner_tree(G, subT) << endl;
    }
    return 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));
 }

Vec<string> getVec(istream &is)
{
	Vec<string> svec;
	string s;
	while (is >> s)
		svec.push_back(s);
	return svec;
}

void nextFr(int* recPar, int* recNode,int recS ,int offset, int* parents, Vec &Fr )
{
    for (int i = 0; i < recS; i++)
        if (parents[recNode[i]-offset] == -1){
            Fr.push_back(recNode[i]);
            parents[recNode[i]-offset] = recPar[i];
        }
}

int main(int argc, char* argv[])
{
    int rank,size,offset;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);
  
    ostringstream convert;
    convert << rank+1;
    string file = "data"+ convert.str();
    int numLocal, totalNode;
    Graph g(rank,file);

    Matpair buf(4);
    Vec F;
    numLocal = g.localNode();
    offset = rank*numLocal;
    int root = 512;
    int finish,localfinish;
    int parents[numLocal];
    for (int i=0;i<numLocal;i++){
        parents[i] = -1;
    }
    if (rank == root/numLocal){
        F.push_back(root);
        parents[root-offset] = -2;}
    localfinish = !F.empty(); 

    Vec nxFr;
   
    int dep=0;
    int depth[numLocal];
    for (int i = 0; i < numLocal; i++){
	    depth[i]=0;
    }

    while(1){
    	localfinish=!F.empty();
	MPI_Barrier(MPI_COMM_WORLD);
	MPI_Allreduce(&localfinish,&finish,1,MPI_INT,MPI_SUM,MPI_COMM_WORLD);
    	if (finish==0)
		break;
        if (!F.empty()){
	   for (Vec::iterator i = F.begin();i != F.end(); i++){
		depth[*i-offset] = dep+1;
		cout << "node "<< *i <<" depth: "<<dep+1<<endl;
	   }
	}

        nextFrBuf(g,F,rank,size,buf,offset);
        alltoallPersonalized(buf,parents,nxFr,size,offset);
	F=nxFr;
	dep++;
    } 

    MPI_Finalize();
    return 0;
}

Vec  NetworkLayer:: getOutput(){
    Vec output; 
    
    for(int i=0;i<Neurons.size();i++){
        output.push_back(Neurons[i].getOutput());       
    }

    return output;
}

    //template definition
    void calculatePseudo(typename Kernel::Vector& point, Vec& v1, typename Kernel::Vector& segment, Vec& v2) {
        Vector3 dir = (segment.template head<3>() - segment.template tail<3>()).normalized();
        Vector3 pp = segment.head(3) + (segment.head(3)-point.head(3)).norm()*dir;
#ifdef DCM_USE_LOGGING
        if(!boost::math::isnormal(pp.norm()))
            BOOST_LOG_SEV(log, error) << "Unnormal pseudopoint detected";
#endif
        v2.push_back(pp);
    };