自学教程：C++ tmp2函数代码示例

void DumpUnfreed(){	AllocList::iterator i;	unsigned int totalSize = 0;	if(!allocList)		return;	CFile f("/tmp/enigma2_mem.out", "w");	if (!f)		return;	size_t len = 1024;	char *buffer = (char*)malloc(1024);	for(i = allocList->begin(); i != allocList->end(); i++)	{		unsigned int tmp;		fprintf(f, "%s/tLINE %d/tADDRESS %p/t%d unfreed/ttype %d (btcount %d)/n",			i->second.file, i->second.line, (void*)i->second.address, i->second.size, i->second.type, i->second.btcount);		totalSize += i->second.size;		char **bt_string = backtrace_symbols( i->second.backtrace, i->second.btcount );		for ( tmp=0; tmp < i->second.btcount; tmp++ )		{			if ( bt_string[tmp] )			{				char *beg = strchr(bt_string[tmp], '(');				if ( beg )				{					std::string tmp1(beg+1);					int pos1=tmp1.find('+'), pos2=tmp1.find(')');					if ( pos1 != std::string::npos && pos2 != std::string::npos )					{						std::string tmp2(tmp1.substr(pos1,(pos2-pos1)));						tmp1.erase(pos1);						if (tmp1.length())						{							int state;							abi::__cxa_demangle(tmp1.c_str(), buffer, &len, &state);							if (!state)								fprintf(f, "%d %s%s/n", tmp, buffer,tmp2.c_str());							else								fprintf(f, "%d %s/n", tmp, bt_string[tmp]);						}					}				}				else					fprintf(f, "%d %s/n", tmp, bt_string[tmp]);			}		}		free(bt_string);		if (i->second.btcount)			fprintf(f, "/n");	}	free(buffer);	fprintf(f, "-----------------------------------------------------------/n");	fprintf(f, "Total Unfreed: %d bytes/n", totalSize);	fflush(f);};

int DFInstanceLinux::write_raw(const VIRTADDR &addr, const int &bytes,                               void *buffer) {    // try to attach, will be ignored if we're already attached    attach();    /* Since most kernels won't let us write to /proc/<pid>/mem, we have to poke     * out data in n bytes at a time. Good thing we read way more than we write.     *     * On x86-64 systems, the size that POKEDATA writes is 8 bytes instead of     * 4, so we need to use the sizeof( long ) as our step size.     */    // TODO: Should probably have a global define of word size for the    // architecture being compiled on. For now, sizeof(long) is consistent    // on most (all?) linux systems so we'll keep this.    uint stepsize = sizeof( long );    uint bytes_written = 0; // keep track of how much we've written    uint steps = bytes / stepsize;    if (bytes % stepsize)        steps++;    LOGD << "WRITE_RAW: WILL WRITE" << bytes << "bytes over" << steps << "steps, with stepsize " << stepsize;    // we want to make sure that given the case where (bytes % stepsize != 0) we don't    // clobber data past where we meant to write. So we're first going to read    // the existing data as it is, and then write the changes over the existing    // data in the buffer first, then write the buffer with stepsize bytes at a time     // to the process. This should ensure no clobbering of data.    QByteArray existing_data(steps * stepsize, 0);    read_raw(addr, (steps * stepsize), existing_data);    LOGD << "WRITE_RAW: EXISTING OLD DATA     " << existing_data.toHex();    // ok we have our insurance in place, now write our new junk to the buffer    memcpy(existing_data.data(), buffer, bytes);    QByteArray tmp2(existing_data);    LOGD << "WRITE_RAW: EXISTING WITH NEW DATA" << tmp2.toHex();    // ok, now our to be written data is in part or all of the exiting data buffer    long tmp_data;    for (uint i = 0; i < steps; ++i) {        int offset = i * stepsize;        // for each step write a single word to the child        memcpy(&tmp_data, existing_data.mid(offset, stepsize).data(), stepsize);        QByteArray tmp_data_str((char*)&tmp_data, stepsize);        LOGD << "WRITE_RAW:" << hex << addr + offset << "HEX" << tmp_data_str.toHex();        if (ptrace(PTRACE_POKEDATA, m_pid, addr + offset, tmp_data) != 0) {            perror("write word");            break;        } else {            bytes_written += stepsize;        }        long written = ptrace(PTRACE_PEEKDATA, m_pid, addr + offset, 0);        QByteArray foo((char*)&written, stepsize);        LOGD << "WRITE_RAW: WE APPEAR TO HAVE WRITTEN" << foo.toHex();    }    // attempt to detach, will be ignored if we're several layers into an attach chain    detach();    // tell the caller how many bytes we wrote    return bytes_written;}

void ompl::base::ProjectionMatrix::project(const double *from, EuclideanProjection &to) const{    namespace nu = boost::numeric::ublas;    // create a temporary uBLAS vector from a C-style array without copying data    nu::shallow_array_adaptor<const double> tmp1(mat.size2(), from);    nu::vector<double, nu::shallow_array_adaptor<const double>> tmp2(mat.size2(), tmp1);    to = prod(mat, tmp2);}

void findPairTree(message &M1, message &M2, const difference &D, const DifferentialPath &P, int max_clique_size, ofstream& changes, int counter, message &M1_old, message &M2_old){	if (counter > 10)		return;	vector<vector<int>> neutral_vectors;	vector<vector<int>> tmp_neutral_vectors;	vector<vector<int>> first_level, second_level;	construct_neutral_set(M1, M2, D, P);	read(neutral_vectors);	set<int> clique;	vector<vector<int>> best_bits;	for (auto i = neutral_vectors.begin(); i != neutral_vectors.end(); i++){		message tmp1(M1);		message tmp2(M2);		xor(tmp1.W, *i);		xor(tmp2.W, *i);		D.modify(tmp1, tmp2);		construct_neutral_set(tmp1, tmp2, D, P);		read(tmp_neutral_vectors);		adj_matrix adj(tmp_neutral_vectors.size());		adj.fill(tmp_neutral_vectors, tmp1, tmp2, D, P);		kerbosh(adj.adj, adj.adj[1].size(), clique, tmp_neutral_vectors);		if (clique.size() == max_clique_size){			first_level.push_back({ (*i)[0], (*i)[1], (*i)[2], (*i)[3], (*i)[4] });		}		if (clique.size() > max_clique_size){			max_clique_size = clique.size();			first_level.clear();			first_level.push_back({ (*i)[0], (*i)[1], (*i)[2], (*i)[3], (*i)[4] });			if (clique.size() >= 35){				printGoodBits(M1_old, tmp1, changes);			}		}		tmp_neutral_vectors.clear();		clique.clear();	}	for (auto i = first_level.begin(); i != first_level.end(); i++){		message tmp1(M1);		message tmp2(M2);		xor(tmp1.W, *i);		xor(tmp2.W, *i);		D.modify(tmp1, tmp2);		findPairTree(tmp1, tmp2, D, P, max_clique_size, changes, ++counter, M1_old, M2_old);	}	return;}

void vernama(){    std::ifstream msg("example", std::ios::binary | std::ios::in);    if (!msg.is_open()) {        std::cerr << "File not found" << std::endl;    }    // Get size of file in chars    msg.seekg (0, std::ios_base::end);    int size = msg.tellg();    msg.seekg (0, std::ios_base::beg);    std::default_random_engine gen;    std::uniform_int_distribution<llong> random(0, 255);    // Create keys    std::ofstream keys_out("vernama_keys", std::ios::binary | std::ios::out);    for (size_t i = 0; i < static_cast<size_t>(size); ++i) {        llong tmp = random(gen);        keys_out.write((char*)&tmp, sizeof(llong));    }    keys_out.close();    llong tmp;    llong buf;    std::ofstream out("vernama_encode", std::ios::binary | std::ios::out);    std::ifstream keys_in("vernama_keys", std::ios::binary | std::ios::in);    for (int i = 0; msg.read((char*)&buf, sizeof(char)); ++i) {        llong key;        keys_in.read((char*)&key, sizeof(llong));        tmp = buf ^ key;        out.write((char*)&tmp, sizeof(llong));    }    msg.close();    out.close();    // Move pointer in begin of file    keys_in.seekg(0, std::ios::beg);    std::ofstream decmsg("vernama_decode", std::ios::binary | std::ios::out);    std::ifstream tmp2("vernama_encode", std::ios::binary | std::ios::in);    if (!tmp2.is_open()) {        std::cerr << "File with name ""vernama_encode"" not found" << std::endl;        exit(1);    }    for (int i = 0; tmp2.read((char*)&buf, sizeof(llong)); ++i) {        llong key;        keys_in.read((char*)&key, sizeof(llong));        tmp = buf ^ key;        decmsg.write((char*)&tmp, sizeof(char));    }    keys_in.close();    decmsg.close();    tmp2.close();}

  MechanicsResidual<EvalT, Traits>::  MechanicsResidual(Teuchos::ParameterList& p,                    const Teuchos::RCP<Albany::Layouts>& dl) :    stress_   (p.get<std::string>("Stress Name"),dl->qp_tensor),    def_grad_ (p.get<std::string>("DefGrad Name"),dl->qp_tensor),    w_grad_bf_(p.get<std::string>("Weighted Gradient BF Name"),dl->node_qp_vector),    w_bf_     (p.get<std::string>("Weighted BF Name"),dl->node_qp_scalar),    residual_ (p.get<std::string>("Residual Name"),dl->node_vector),    have_pore_pressure_(p.get<bool>("Have Pore Pressure",false)),    have_body_force_   (p.get<bool>("Have Body Force",false)),    have_strain_ (false)  {    this->addDependentField(stress_);    this->addDependentField(def_grad_);    this->addDependentField(w_grad_bf_);    this->addDependentField(w_bf_);    this->addEvaluatedField(residual_);    this->setName("MechanicsResidual"+PHX::TypeString<EvalT>::value);    // logic to modify stress in the presence of a pore pressure    if (have_pore_pressure_) {      // grab the pore pressure      PHX::MDField<ScalarT,Cell,QuadPoint>         tmp(p.get<std::string>("Pore Pressure Name"), dl->qp_scalar);      pore_pressure_ = tmp;      // grab Boit's coefficient      PHX::MDField<ScalarT,Cell,QuadPoint>         tmp2(p.get<std::string>("Biot Coefficient Name"), dl->qp_scalar);      biot_coeff_ = tmp2;      this->addDependentField(pore_pressure_);      this->addDependentField(biot_coeff_);    }    if (have_body_force_) {      // grab the pore pressure      PHX::MDField<ScalarT,Cell,QuadPoint,Dim>         tmp(p.get<std::string>("Body Force Name"), dl->qp_vector);      body_force_ = tmp;      this->addDependentField(body_force_);    }    if ( p.isType<bool>("Strain Flag") )      have_strain_ = p.get<bool>("Strain Flag");    std::vector<PHX::DataLayout::size_type> dims;    w_grad_bf_.fieldTag().dataLayout().dimensions(dims);    num_nodes_ = dims[1];    num_pts_   = dims[2];    num_dims_  = dims[3];    int worksetSize = dims[0];    Teuchos::RCP<ParamLib> paramLib =       p.get< Teuchos::RCP<ParamLib> >("Parameter Library");  }

void stimulus::entry() {    reset.write(true);    wait();    reset.write(false);    sc_signed       tmp1(8);    sc_signed       tmp2(8);    long            tmp3;    int             tmp4;    short           tmp5;    char            tmp6;    char            tmp7;    bool            tmp8;    sc_unsigned     tmp9(4);    sc_unsigned     tmp10(4);    tmp1 = "0b01010101";    tmp2 = "0b00000010";    tmp3 = 12345678;    tmp4 = -123456;    tmp5 = 20000;    tmp6 = '$';     tmp7 = 'A';    tmp8 = "0";    tmp9 = "0b0001";    tmp10 = "0b0010";    while(true){       out_valid.write(true);       out_value1.write(tmp1);       out_value2.write(tmp2);       out_value3.write(tmp3);       out_value4.write(tmp4);       out_value5.write(tmp5);       out_value6.write(tmp6);       out_value7.write(tmp7);       out_value8.write(tmp8);       out_value9.write(tmp9);       out_value10.write(tmp10);       cout << "Stimuli: " << tmp1 << " " << tmp2 << " " << tmp3 << " " << tmp4 << " "	    << tmp5 << " " << tmp6 << " " << tmp7 << " " << tmp8 << " " << tmp9  << " " << tmp10 <<endl;       tmp1 = tmp1 + 2;       tmp2 = tmp2 + 1;       tmp3 = tmp3 + 5;       tmp4 = tmp4 + 3;       tmp5 = tmp5 + 6;       tmp7 = tmp7 + 1;       tmp8 = !tmp8;       tmp9 = tmp9 + 1;       tmp10 = tmp10 + 1;       do { wait(); } while (in_ack==false);       out_valid.write(false);       wait();    }}

void head_callback(const geometry_msgs::Point::ConstPtr& msg){	//if in automode and estop is not set, it's good to 	if(auto_mode == 1 && estop == 0){		std_msgs::String result;		//if send out velocity command to control the robot		if(start_flag == 1){			float theta = atan2(-1*(msg->x),msg->z);//our model has the opposite coordinates frame with the kinect frame, so negative the x value			printf("theta:%f/n",theta);			printf("head x %f/n",msg->x);			printf("head y %f/n",msg->y);			printf("head z %f/n",msg->z);			if(fabs(theta) >= 0.5){				printf("Out of the range of the kinect/n");				result.data = "A00B00";				printf("velocity A00 B00/n");			} else {				if(msg->z <= 1200){					printf("in the 1.5m/n");					result.data = "A00B00";					printf("velocity A00 B00/n");				}else{					if(fabs(theta) > 0.05){						printf("Turn/n");						float k=10.0;						float Vmax = 20.0;						int left_vel = -1 * k*theta + Vmax/2;						int right_vel = Vmax/2 + k*theta;						char tmp[7];						if(left_vel < 16 && right_vel > 16){							sprintf(tmp,"A0%xB%x",left_vel, right_vel);						}else if(right_vel < 16 && left_vel > 16){							sprintf(tmp,"A%xB0%x",left_vel, right_vel);						}else if(left_vel < 16 && right_vel < 16){							sprintf(tmp,"A0%xB0%x",left_vel, right_vel);						}else{							sprintf(tmp,"A%xB%x",left_vel, right_vel);						}						printf("Velocity Command %s/n",tmp);						std::string tmp2(tmp);						result.data = tmp2;					} else {						printf("Move Straight/n");						result.data = "A10B10";//set constant moving speed						printf("velocity A10 B10/n");					}				}			}		}else{			printf("Stop Gesture/n");			result.data = "A00B00";			printf("velocity A00 B00/n");		}		cmd_vel_pub.publish(result);	}}

	bool operator()(std::string const& s1, std::string const& s2)	{		std::string tmp1(s1);		std::sort(tmp1.begin(), tmp1.end());				std::string tmp2(s2);		std::sort(tmp2.begin(), tmp2.end());		return tmp1 < tmp2;	}

Expression NonsmoothOperator::operator*( const Operator& arg ) const{    Expression tmp2(arg);    Expression tmp1(*this);    return tmp1*tmp2;}

void P_graded(vector<double> &P, const vector<double> &par,    const NumericMatrix &Theta, const NumericVector &ot, const int &N,    const int &nfact, const int &nint, const int &itemexp, const int &israting){    const int parsize = par.size();    vector<double> a(nfact);    for(int i = 0; i < nfact; ++i) a[i] = par[i];    vector<double> d(nint, 0.0);    if(israting){        const double t = par[parsize-1];        for(int i = nfact; i < parsize - 1; ++i)            d[i - nfact] = par[i] + t;    } else {        for(int i = nfact; i < parsize; ++i)            d[i - nfact] = par[i];    }    int notordered = 0;    for(int i = 1; i < nint; ++i)        notordered += d[i-1] <= d[i];     if(notordered){        for(int i = 0; i < P.size(); ++i)            P[i] = 0.0;    } else {                const double nullzero = 0.0, nullone = 1.0;        NumericMatrix Pk(N, nint + 2);            for(int i = 0; i < N; ++i)            Pk(i,0) = 1.0;        for(int i = 0; i < nint; ++i){            vector<double> tmp1(N), tmp2(N);            itemTrace(tmp1, tmp2, a, &d[i], Theta, &nullzero, &nullone, ot);            for(int j = 0; j < N; ++j)                Pk(j,i+1) = tmp2[j];        }        if(itemexp){            int which = N * (nint + 1) - 1;            for(int i = (Pk.ncol()-2); i >= 0; --i){                for(int j = (N-1); j >= 0; --j){                    P[which] = Pk(j,i) - Pk(j,i+1);                    if(P[which] < 1e-20) P[which] = 1e-20;                    else if((1.0 - P[which]) < 1e-20) P[which] = 1.0 - 1e-20;                    --which;                }            }        } else {            int which = 0;            for(int i = 0; i < Pk.ncol(); ++i){                for(int j = 0; j < Pk.nrow(); ++j){                    P[which] = Pk(j,i);                    ++which;                }            }        }    }}

void checkup::checkupfc(vector<vector<Point> > contours_in, std::vector<int> angulo, std::vector<int> *posiciones, vector<vector<Point> > *contours_out ){    int n;    n=angulo.size();    std::vector<int> tmp2(n,0);    std::vector<int> tmp3(n,0);    int tmp1=0;    tmp1=angulo[0];//    cout<<endl;//    cout<<"Angulo original es: ";//    for(int i=0; i<angulo.size(); i++){//      // cout<<angulo[i]<<" ";//    }    for(int i=0;i<angulo.size();i++){        if(abs(angulo[i]-tmp1)<=5)            tmp2[i]=1;        else            tmp2[i]=angulo[i];    }   // cout<<endl; //   cout<<endl;    for(int i=0;i<angulo.size();i++){        if(tmp2[i]!=1){            for(int k=0;k<angulo.size();k++){                if(abs(angulo[k]-tmp2[i])<=5)                    tmp3[k]=1;                else                    tmp3[k]=tmp2[i];            }        }    }//    cout<<endl;//    for(int k=0;k<angulo.size();k++){//        if(tmp2[k]==1)//             cout<<"Igual en posicion tmp2: "<<k<<endl;//    }//    for(int k=0;k<angulo.size();k++){//        if(tmp3[k]==1)//          //   cout<<"Igual en posicion tmp3: "<<k<<endl;//    }    // Separar contornos   // if(tmp)}

    virtual std::vector<Vector> placeObjects(const Vector & centre)    {      std::vector<Vector> localsites;          Vector start{0,0,0}, tmp{0,0,0};          for (int iStep = 0; iStep < chainlength; ++iStep)	{      	  bool test = true;		  while(test)	    {	      test = false;	    	      {		Vector tmp2(getRandVec());		tmp2 /= tmp2.nrm();	      		tmp = start + tmp2 * walklength;	      }	    	      for (const Vector & vec : localsites)		if ((vec - tmp).nrm() <= diameter)		  test = true;	    }			  localsites.push_back(start);		  start = tmp;	}        //Centre the chain in the unit cell      {	Vector offset{0,0,0};      	for (const Vector & vec : localsites)	  offset += vec;      	offset /= localsites.size();      	// move to the centre and offset	for (Vector & vec : localsites)	  vec -= offset + centre;      }      std::vector<Vector> retval;      for (const Vector& vec : localsites)	{	  const std::vector<Vector>& newsites = uc->placeObjects(vec);	  retval.insert(retval.end(), newsites.begin(), newsites.end());	}      return retval;        }

 int rob(vector<int>& nums) {     if(nums.empty())         return 0;     if (nums.size() < 4)         return *(max_element(nums.begin(), nums.end()));     vector<int> tmp1(nums.begin() + 1, nums.end());     int max1 = Sol(tmp1);     vector<int> tmp2(nums.begin() + 2, nums.end() - 1);     int max2 = nums[0] + Sol(tmp2);     return max(max1, max2);          }

SEXP updateVertexNormals(SEXP vb_, SEXP it_,SEXP angweight_) {  try {    typedef unsigned int uint;    bool angweight = Rcpp::as<bool>(angweight_);    NumericMatrix vb(vb_);    IntegerMatrix it(it_);    mat vbA(vb.begin(),vb.nrow(),vb.ncol());    mat normals = vbA*0;    imat itA(it.begin(),it.nrow(),it.ncol());    //setup vectors to store temporary data    colvec tmp0(3), tmp1(3), tmp2(3), angtmp(3), ntmp(3);    int nit = it.ncol();    for (int i=0; i < nit; ++i) {      tmp0 = vbA.col(itA(1,i))-vbA.col(itA(0,i));      tmp1 = vbA.col(itA(2,i))-vbA.col(itA(0,i));      if (angweight) {	tmp2 = vbA.col(itA(1,i))-vbA.col(itA(2,i));	angtmp(0) = angcalcArma(tmp0,tmp1);	angtmp(1) = angcalcArma(tmp0, tmp2);	angtmp(2) = angcalcArma(-tmp1, tmp2);      }      crosspArma(tmp0,tmp1,ntmp);      for (int j=0; j < 3; ++j) {	double co = dot(normals.col(itA(j,i)),ntmp);      	if (co < 0)  {	  if (!angweight) {	    normals.col(itA(j,i)) -= ntmp;	  } else {	    normals.col(itA(j,i)) -= ntmp*angtmp(j);	  }	} else {	  if (! angweight) {	    normals.col(itA(j,i)) += ntmp;	  } else {	    normals.col(itA(j,i)) += ntmp*angtmp(j);	  }	}      }    }    for (uint i=0; i < normals.n_cols; ++i) {      double nlen = norm(normals.col(i),2);      if (nlen > 0)	normals.col(i) /= nlen;    }		           return Rcpp::wrap(normals);  } catch (std::exception& e) {    ::Rf_error( e.what());  } catch (...) {    ::Rf_error("unknown exception");  }}

    int ZmqEnd::startMsgLoop() {        std::unique_ptr<std::thread> tmp1(new std::thread(std::mem_fn(&ZmqEnd::frontThreadFunc), this));        mPtrMsgRThread = std::move(tmp1);        std::unique_ptr<std::thread> tmp2(new std::thread(std::mem_fn(&ZmqEnd::backThreadFunc), this));        mPtrMsgDThread = std::move(tmp2);              mQuerySock.setsockopt(ZMQ_IDENTITY, mQuerySockID.c_str(), mQuerySockID.size());        mQuerySock.connect(mExternUri);        return 0;        }

double spec_template::sample_theta_conditional_revprop_logpdf(){    vector<double> Lbeta(L[0].size(),0);    vector<double> meanvec(L[0].size(),0);    MVprod(&L, &beta_draw, &Lbeta);    double logprob=0;    vector<double> var(psi_draw.size(),0);    vector<double> meanbuf(pars.p);        if(WAVELETS)    {       for(int i = 0; i < pars.p; i++)	  {	    var[i]=(1/(1+psi_draw[i]));	    meanbuf[i]=var[i]*(dataWy[i]-Lbeta[i]);	  }	  idwt(meanbuf, pars.levsize, pars.h_vec, meanvec);  	  vector<double> y_draw(pars.n,0.0);	      idwt(theta_draw, pars.levsize, pars.h_vec, y_draw);  	  for (int j = 0; j <pars.n; j++)	  {  	    logprob=logprob+truncated_normal_logpdf(y_draw[j], meanvec[j], sqrt(Temp/lambda_draw), tau_draw[j]);	  } 		  vector<double> addedpoints(pars.p-pars.n,0.0);	  MVprod(&vex,&meanbuf,&addedpoints); 		  vector<double> tmp2(pars.p-pars.n,0.0);	  MVprod(&vex,&theta_draw,&tmp2);		  VVdif(&tmp2,&addedpoints, &tmp2);	  Vconstprod(&tmp2,sqrt(Temp/lambda_draw), &tmp2);		  for(int j = 0; j <pars.p-pars.n; j++)	    logprob+=normlogpdf(tmp2[j], 0, 1);   }   else   {      for(unsigned int i = 0; i<psi_draw.size(); i++)  	  {	    var[i] = (1/(1 + psi_draw[i]));	    meanvec[i] = var[i]*(dataWy[i] - Lbeta[i]);	  }        	  for (int j = 0; j < pars.p; j++) 	    logprob=logprob+truncated_normal_logpdf(theta_draw[j], meanvec[j],sqrt(Temp*var[j]/lambda_draw), tau_draw[j]);   }   return logprob;}

int ExecutionTracker::SimulateCondBroadcast(thrID myself, void * ret_addr,        pthread_cond_t * cond) {    SignalPointInfo tmp(ret_addr, IS_BROADCAST, myself, cond, cond_map);    wakeThreadWaitingOnCond(&tmp);    glock();    enableThread(myself);    handleSimulateCondBroadcast(myself, ret_addr, cond);    SchedPointInfo tmp2(ret_addr, "Simulate Broadcast", myself,            enable_map, IS_NOT_YIELD, cond);    schedule(&tmp2);    gunlock();    pauseThread(myself);    return OPERATION_SUCCESSFUL;  }

bool checkEqual(Queue *queue, Buf *buf1, Buf *buf2, int size) {  std::unique_ptr<int[]> tmp1(new int[size]);  std::unique_ptr<int[]> tmp2(new int[size]);  queue->readBlocking(buf1, 0, sizeof(int) * size, tmp1.get());  queue->readBlocking(buf2, 0, sizeof(int) * size, tmp2.get());  int err = 0;  for (int i = 0; i < size; ++i) {    if (tmp1[i] != tmp2[i]) {      printf("%d %d %d/n", i, tmp1[i], tmp2[i]);      if (++err >= 10) { return false; }    }  }  return true;}

//复数类的四则运算int main(){	Fushu a(10);	Fushu b(20);	Fushu tmp1(a+b);	tmp1.Show();	Fushu tmp2(a-b);	tmp2.Show();	Fushu tmp3(a*b);	tmp3.Show();	Fushu tmp4(a/b);	tmp4.Show();	return 0;}

/*fname:   path to input image*/void Dip2::generateNoisyImages(string fname){    // load image, force gray-scale   cout << "load original image" << endl;   Mat img = imread(fname, 0);   if (!img.data){      cerr << "ERROR: file " << fname << " not found" << endl;      cout << "Press enter to exit"  << endl;      cin.get();      exit(-3);   }   // convert to floating point precision   img.convertTo(img,CV_32FC1);   cout << "done" << endl;   // save original   imwrite("original.jpg", img);	     // generate images with different types of noise   cout << "generate noisy images" << endl;   // some temporary images   Mat tmp1(img.rows, img.cols, CV_32FC1);   Mat tmp2(img.rows, img.cols, CV_32FC1);   // first noise operation   float noiseLevel = 0.15;   randu(tmp1, 0, 1);   threshold(tmp1, tmp2, noiseLevel, 1, CV_THRESH_BINARY);   multiply(tmp2,img,tmp2);   threshold(tmp1, tmp1, 1-noiseLevel, 1, CV_THRESH_BINARY);   tmp1 *= 255;   tmp1 = tmp2 + tmp1;   threshold(tmp1, tmp1, 255, 255, CV_THRESH_TRUNC);   // save image   imwrite("noiseType_1.jpg", tmp1);       // second noise operation   noiseLevel = 50;   randn(tmp1, 0, noiseLevel);   tmp1 = img + tmp1;   threshold(tmp1,tmp1,255,255,CV_THRESH_TRUNC);   threshold(tmp1,tmp1,0,0,CV_THRESH_TOZERO);   // save image   imwrite("noiseType_2.jpg", tmp1);	cout << "done" << endl;	cout << "Please run now: dip2 restorate" << endl;}

// Compute features using Harris corner detection methodvoid ComputeHarrisFeatures(CFloatImage &image, FeatureSet &features){	// Create grayscale image used for Harris detection	CFloatImage grayImage = ConvertToGray(image);	// Create image to store Harris values	CFloatImage harrisImage(image.Shape().width,image.Shape().height,1);	// Create image to store local maximum harris values as 1, other pixels 0	CByteImage harrisMaxImage(image.Shape().width,image.Shape().height,1);	// Create image to store orientation values	CFloatImage orientationImage(image.Shape().width, image.Shape().height, 1);	// Compute the harris score at each pixel position, storing the result in in harrisImage. 	computeHarrisValues(grayImage, harrisImage, orientationImage);	// Threshold the harris image and compute local maxima.	computeLocalMaxima(harrisImage,harrisMaxImage);	// Save images	CByteImage tmp(harrisImage.Shape());	CByteImage tmp2(harrisImage.Shape());	convertToByteImage(harrisImage, tmp);	convertToByteImage(grayImage, tmp2);	WriteFile(tmp2, "grayImg.tga");	WriteFile(tmp, "harris.tga");	WriteFile(harrisMaxImage, "harrisMax.tga");	// Loop through feature points in harrisMaxImage and fill in id, type, x, y, and angle 	// information needed for descriptor computation for each feature point, then add them	// to feature set	int id = 0;	for (int y=0; y < harrisMaxImage.Shape().height; y++) {		for (int x=0; x < harrisMaxImage.Shape().width; x++) {			if (harrisMaxImage.Pixel(x, y, 0) == 1) {				Feature f;				f.id = id;				f.type = 2;				f.x = x;				f.y = y;				f.angleRadians = orientationImage.Pixel(x,y,0);								features.push_back(f);				id++;			}		}	}}

int test_rotate90(){#ifdef _MSC_VER	cv::Mat matSrc = cv::imread("E:/GitCode/OpenCV_Test/test_images/1.jpg", 1);#else		cv::Mat matSrc = cv::imread("test_images/1.jpg", 1);#endif	if (!matSrc.data) {		std::cout << "read image fail" << std::endl;		return -1;	}	int width = matSrc.cols;	int height = matSrc.rows;	fbc::Mat_<uchar, 3> mat1(height, width, matSrc.data);	fbc::Mat_<uchar, 3> matTranspose(width, height);	fbc::transpose(mat1, matTranspose);	// clockwise rotation  90	fbc::Mat_<uchar, 3> matRotate90(width, height);	fbc::flip(matTranspose, matRotate90, 1);	cv::Mat tmp2(width, height, CV_8UC3, matRotate90.data);#ifdef _MSC_VER	cv::imwrite("E:/GitCode/OpenCV_Test/test_images/rotate_90.jpg", tmp2);#else		cv::imwrite("test_images/rotate_90.jpg", tmp2);#endif	// clockwise rotation 180	fbc::Mat_<uchar, 3> matRotate180(height, width);	fbc::flip(mat1, matRotate180, -1);	cv::Mat tmp3(height, width, CV_8UC3, matRotate180.data);#ifdef _MSC_VER	cv::imwrite("E:/GitCode/OpenCV_Test/test_images/rotate_180.jpg", tmp3);#else	cv::imwrite("test_images/rotate_180.jpg", tmp3);#endif	// clockwise rotation 270	fbc::Mat_<uchar, 3> matRotate270(width, height);	fbc::flip(matTranspose, matRotate270, 0);	cv::Mat tmp4(matTranspose.rows, matTranspose.cols, CV_8UC3, matRotate270.data);#ifdef _MSC_VER	cv::imwrite("E:/GitCode/OpenCV_Test/test_images/rotate_270.jpg", tmp4);#else	cv::imwrite("test_images/rotate_270.jpg", tmp4);#endif	return 0;}

  void NFFT2DGadget::extract_trajectory_and_dcw_from_queue  ( ACE_Message_Queue<ACE_MT_SYNCH> *queue, cuNDArray<floatd2> *traj, cuNDArray<float> *dcw )  {    // Extract trajectory and (if present) density compensation weights.    // They are stored as a float array of dimensions: {2,3} x #samples_per_readout x #readouts.    // We need    // - a floatd2 trajectory array     // - a float dcw array     //            if( num_trajectory_dims_ == 2 ){      boost::shared_ptr< hoNDArray<float> > host_traj = extract_trajectory_from_queue( queue );      std::vector<size_t> dims_1d; dims_1d.push_back(host_traj->get_size(1)*host_traj->get_size(2));      hoNDArray<floatd2> host_traj2(&dims_1d,(floatd2*)host_traj->get_data_ptr());      *traj = cuNDArray<floatd2>(host_traj2);    }    else{      boost::shared_ptr< hoNDArray<float> > host_traj_dcw = extract_trajectory_from_queue( queue );      std::vector<size_t> order;      order.push_back(1); order.push_back(2); order.push_back(0);            boost::shared_ptr< hoNDArray<float> > host_traj_dcw_shifted = permute( host_traj_dcw.get(), &order );            std::vector<size_t> dims_1d;      dims_1d.push_back(host_traj_dcw_shifted->get_size(0)*host_traj_dcw_shifted->get_size(1));            hoNDArray<float> tmp(&dims_1d, host_traj_dcw_shifted->get_data_ptr()+2*dims_1d[0]);      *dcw = tmp;            std::vector<size_t> dims_2d = dims_1d; dims_2d.push_back(2);      order.clear(); order.push_back(1); order.push_back(0);            tmp.create(&dims_2d, host_traj_dcw_shifted->get_data_ptr());      auto _traj = permute( &tmp, &order );      hoNDArray<floatd2> tmp2(&dims_1d,(floatd2*)_traj->get_data_ptr());            *traj = cuNDArray<floatd2>(tmp2);    }    std::vector<size_t >dims_2d;    dims_2d.push_back(traj->get_number_of_elements());    dims_2d.push_back(1); // Number of frames    traj->reshape(&dims_2d);    if( num_trajectory_dims_ == 3 ) dcw->reshape(&dims_2d);  }

void SimpleXML::Tag::appendAttribString(string& tmp) {	for(auto& i: attribs) {		tmp.append(i.first);		tmp.append("=/"", 2);		if(needsEscape(i.second, true)) {			string tmp2(i.second);			escape(tmp2, true);			tmp.append(tmp2);		} else {			tmp.append(i.second);		}		tmp.append("/" ", 2);	}	tmp.erase(tmp.size()-1);}

bool		Kitchen::checkError(std::string &str){  std::string	tmp(str);  std::string	tmp2("");  int	      	n = 0;  tmp2 = tmp.substr(0, 3);  if (tmp2 != "c: " && tmp2 != "r: ")    return (false);  tmp.erase(0, 3);  n = std::count(tmp.begin(), tmp.end(), ' ');  if (n > 1)    return (false);  return (true);}

void SimpleXML::Tag::appendAttribString(string& tmp) {    for(StringPairIter i = attribs.begin(); i!= attribs.end(); ++i) {        tmp.append(i->first);        tmp.append("=/"", 2);        if(needsEscape(i->second, true)) {            string tmp2(i->second);            escape(tmp2, true);            tmp.append(tmp2);        } else {            tmp.append(i->second);        }        tmp.append("/" ", 2);    }    tmp.erase(tmp.size()-1);}

 string convertToTitle(int n) {          if(n==0) return "";          if(n <=26)     {         char tmp = n + 'A'-1;         string tmp2(1,tmp);         return tmp2;     }     if(n/26!=0 && n%26==0)     {         return convertToTitle(n/26-1) + convertToTitle(26);     }     return convertToTitle(n/26) + convertToTitle(n%26); }

double Stokhos::EpetraMultiVectorOperator::NormInf() const{  // ||A||_inf = || (|A_1| + ... + |A_n|) ||_inf where A_i is the i-th column  // of the multi-vector A  Epetra_Vector tmp1(multi_vec->Map());  Epetra_Vector tmp2(multi_vec->Map());  for (int j=0; j<multi_vec->NumVectors(); j++) {    tmp1.Abs(*((*multi_vec)(j)));    tmp2.Update(1.0, tmp1, 1.0);  }  double nrm;  tmp2.NormInf(&nrm);  return nrm;}