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

void GaussianProcess::update_K(bool all){	//const unsigned int start_idx = all? last_x_size : 0;	const unsigned int start_idx = 0;	const unsigned int x_len = xs.size() - start_idx;// 	const unsigned int num_rows = K.rows();// 	const unsigned int num_cols = K.cols();	/*	if (!all){		assert(num_rows < last_x_size);	}	*/	//K.resize(num_rows+x_len,num_cols+x_len);	K.resize(x_len,+x_len);	for (unsigned int i = 0; i < xs.size(); ++i) {		for (unsigned int j = start_idx; j < xs.size(); ++j) {			const double diff = kernel->eval(xs(j),xs(i));			std::cout << "diff: " << diff << std::endl;			if (diff != diff){				exit(-1);			}			K(i,j) = diff;			K(j,i) = diff;		}	}	stale = false;}

static voidsse_test (void){  assert (ys (1) == xs ());  assert (ys (2) == xs () * 2);  assert (yd (1) == xd ());  assert (yd (2) == xd () * 2);}

voidprint_line(line* t){	fprintf(outfile, "newpath/n");	fprintf(outfile, "4 setlinewidth/n");	fprintf(outfile, "0.3 setgray/n");	fprintf(outfile, "%f %f moveto/n", xs(t->v1[0]), ys(t->v1[1]));	fprintf(outfile, "%f %f lineto/n", xs(t->v2[0]), ys(t->v2[1]));	fprintf(outfile, "stroke/n");}

void print_circle(){	fprintf(outfile, "newpath/n");	fprintf(outfile, "0 setgray/n");	fprintf(outfile, "1 setlinewidth/n");	fprintf(outfile, "%f %f %f 0 360 arc/n", 		(double)(xs(0)), (double)(ys(0)), (double)((xs(RADIUS))-(xs(0))));	fprintf(outfile, "stroke/n");	} 

voidprint_proj_xy(triangle* t){	fprintf(outfile, "newpath/n");	fprintf(outfile, "0.2 setlinewidth/n");	fprintf(outfile, "%f %f moveto/n", xs(t->v1[0]), ys(t->v1[1]));	fprintf(outfile, "%f %f lineto/n", xs(t->v2[0]), ys(t->v2[1]));	fprintf(outfile, "%f %f lineto/n", xs(t->v3[0]), ys(t->v3[1]));	fprintf(outfile, "%f %f lineto/n", xs(t->v1[0]), ys(t->v1[1]));	fprintf(outfile, "stroke/n");}

voidMockReadonlyIndex::build(SortableStrVec& keys) {	const Schema* schema = m_schema;	const byte* base = keys.m_strpool.data();	size_t fixlen = schema->getFixedRowLen();	if (fixlen) {		assert(keys.m_index.size() == 0);		assert(keys.str_size() % fixlen == 0);		m_ids.resize_no_init(keys.str_size() / fixlen);		for (size_t i = 0; i < m_ids.size(); ++i) m_ids[i] = i;		std::sort(m_ids.begin(), m_ids.end(), [=](size_t x, size_t y) {			fstring xs(base + fixlen * x, fixlen);			fstring ys(base + fixlen * y, fixlen);			int r = schema->compareData(xs, ys);			if (r) return r < 0;			else   return x < y;		});	}	else {		if (keys.str_size() >= UINT32_MAX) {			THROW_STD(length_error,				"keys.str_size=%lld is too large", llong(keys.str_size()));		}		// reuse memory of keys.m_index		auto offsets = (uint32_t*)keys.m_index.data();		size_t rows = keys.m_index.size();		m_ids.resize_no_init(rows);		for (size_t i = 0; i < rows; ++i) m_ids[i] = i;		for (size_t i = 0; i < rows; ++i) {			uint32_t offset = uint32_t(keys.m_index[i].offset);			offsets[i] = offset;		}		offsets[rows] = keys.str_size();		std::sort(m_ids.begin(), m_ids.end(), [=](size_t x, size_t y) {			size_t xoff0 = offsets[x], xoff1 = offsets[x+1];			size_t yoff0 = offsets[y], yoff1 = offsets[y+1];			fstring xs(base + xoff0, xoff1 - xoff0);			fstring ys(base + yoff0, yoff1 - yoff0);			int r = schema->compareData(xs, ys);			if (r) return r < 0;			else   return x < y;		});		BOOST_STATIC_ASSERT(sizeof(SortableStrVec::SEntry) == 4*3);		m_keys.offsets.risk_set_data(offsets);		m_keys.offsets.risk_set_size(rows + 1);		m_keys.offsets.risk_set_capacity(3 * rows);		m_keys.offsets.shrink_to_fit();		keys.m_index.risk_release_ownership();	}	m_keys.strpool.swap((valvec<char>&)keys.m_strpool);	m_fixedLen = fixlen;}

int main(){  unsigned long cpu_facilities;  cpu_facilities = i386_cpuid ();  if (cpu_facilities & bit_SSE)    {      assert (ys (1) == xs ());      assert (ys (2) == xs () * 2);      assert (yd (1) == xd ());      assert (yd (2) == xd () * 2);    }  return 0;}

static void validate_quant_solution(ast_manager& m, expr* fml, expr* guard, qe::def_vector const& defs) {    // verify:    //    new_fml => fml[t/x]    scoped_ptr<expr_replacer> rep = mk_expr_simp_replacer(m);    app_ref_vector xs(m);    expr_substitution sub(m);    for (unsigned i = 0; i < defs.size(); ++i) {        xs.push_back(m.mk_const(defs.var(i)));        sub.insert(xs.back(), defs.def(i));    }    rep->set_substitution(&sub);    expr_ref fml1(fml, m);    (*rep)(fml1);    expr_ref tmp(m);    tmp = m.mk_not(m.mk_implies(guard, fml1));    front_end_params fp;    smt::kernel solver(m, fp);    solver.assert_expr(tmp);    lbool res = solver.check();    //SASSERT(res == l_false);    if (res != l_false) {        std::cout << "Validation failed: " << res << "/n";        std::cout << mk_pp(tmp, m) << "/n";        model_ref model;        solver.get_model(model);        model_smt2_pp(std::cout, m, *model, 0);        fatal_error(0);    }}

int main(int argc, char *argv[]){    QCoreApplication app(argc, argv);    if (app.arguments().count() != 2) {        std::cerr << qPrintable(Traverse::tr("Usage: traverse <XML file>")) << std::endl;        return 1;    }    QFile file(app.arguments()[1]);    if (!file.open(QFile::ReadOnly)) {        std::cerr << qPrintable(Traverse::tr("Failed to open file: %1").arg(app.arguments()[1])) << std::endl;        return 1;    }    //! [traverse document]    QXmlStreamReader xs(&file);    while (!xs.atEnd()) {        if (xs.readNextStartElement())            std::cout << qPrintable(xs.name().toString()) << std::endl;    }    //! [traverse document]    file.close();    return 0;}

  void DOMElement::setTextContent(const std::wstring & ws)  {    if(isNull())      return;    std::basic_string<XMLCh> xs(ws.begin(), ws.end());    XELEM(m_wrapped)->setTextContent(xs.c_str());  }

std::vector<T> linSpaceVec(T a, T b, size_t N) {  T h = (b - a) / static_cast<T>(N-1);  std::vector<T> xs(N);  typename std::vector<T>::iterator x;  T val;  for (x = xs.begin(), val = a; x != xs.end(); ++x, val += h)    *x = val;  return xs;}

 std::vector<T> operator()(std::size_t size) {     // Generate double as many elements because many will be discarded by     // applying unique.     result_type xs(source(2 * size));     std::sort(xs.begin(), xs.end());     auto last = std::unique(xs.begin(), xs.end());     xs.erase(last, xs.end());     return std::move(xs); }

int main(){    std::vector<X> xs(10);    set_parameter(xs, 42, &X::foo);    set_parameter(xs, "hello world", &X::splurgle);    for (auto const& x : xs)        std::cout << x.foo << ", " << x.splurgle << "/n";}

 std::vector<T> linspace(T begin, T end, size_t n) {     T h = (end - begin) / static_cast<T>(n-1);     std::vector<T> xs(n);     typename std::vector<T>::iterator it;     T val;     for (it = xs.begin(), val = begin;          it != xs.end(); ++it, val += h)         *it = val;     return xs; }

boxwide_check_box (path ip, SI x1, SI x2, pencil pen) {    SI width, height;    get_wide_parameters (x1, x2, pen, width, height);    array<box> bs (2);    array<SI>  xs (2);    array<SI>  ys (2);    xs[0]= ys[0]= xs[1]= ys[1]= 0;    bs[0]= line_box (decorate_middle (ip), 0, height, width/2, 0, pen);    bs[1]= line_box (decorate_middle (ip), width/2, 0, width, height, pen);    return composite_box (ip, bs, xs, ys);}

void print_number(triangle* t, int n){	float xbar, ybar;	xbar = (t->v1[0] + t->v2[0] + t->v3[0])/3;	ybar = (t->v1[1] + t->v2[1] + t->v3[1])/3;		fprintf(outfile,"newpath/n");	fprintf(outfile,"%f %f moveto/n", xs(xbar), ys(ybar));	fprintf(outfile,"(%d) show/n", n);	fprintf(outfile,"stroke/n");	}

std::vector<double> linspace(const double low, const double high, const size_t n,    double * const step /*= nullptr*/){  std::vector<double> xs(n);  const double dx = (high - low)/(n - 1);  if(step) *step = dx;  for(size_t i = 0; i < n; ++i) {    xs[i] = low + i*dx;  }  return xs;}

void GaussianProcess::observe(double x, double y){	stale = true;	last_x_size = xs.size();	const unsigned int x_size = xs.size();	const unsigned int y_size = ys.size();	xs.resize(x_size+1);	ys.resize(y_size+1);	xs(x_size) = x;	ys(y_size) = y;}

docstring InsetCaptionable::getCaptionHTML(OutputParams const & runparams) const{	InsetCaption const * ins = getCaptionInset();	if (ins == 0)		return docstring();	odocstringstream ods;	XHTMLStream xs(ods);	docstring def = ins->getCaptionAsHTML(xs, runparams);	if (!def.empty())		// should already have been escaped		xs << XHTMLStream::ESCAPE_NONE << def << '/n';	return ods.str();}

 ExecStatus Distinct<View0,View1>::propagate(Space& home, const ModEventDelta&) {   assert(x0.assigned()||x1.assigned());   if (x0.assigned()) {     GlbRanges<View0> xr(x0);     IntSet xs(xr);     ConstSetView cv(home, xs);     GECODE_REWRITE(*this,(DistinctDoit<View1>::post(home(*this),x1,cv)));   } else {     GlbRanges<View1> yr(x1);     IntSet ys(yr);     ConstSetView cv(home, ys);     GECODE_REWRITE(*this,(DistinctDoit<View0>::post(home(*this),x0,cv)));   } }

boxwide_sqobr_box (path ip, SI x1, SI x2, pencil pen) {    SI penw= pen->get_width ();    pencil demipen= pencil (pen->get_color (), penw/2);    path dip= decorate_middle (ip);    SI width= max (x2-x1, 6*penw), height= 6*penw;    array<box> bs (3);    array<SI>  xs (3);    array<SI>  ys (3);    xs[0]= ys[0]= xs[1]= ys[1]= xs[2]= ys[2]= 0;    bs[0]= line_box (dip, 0, height, width, height, pen);    bs[1]= line_box (dip, 0, height, 0, 0, demipen);    bs[2]= line_box (dip, width, height, width, 0, demipen);    return composite_box (ip, bs, xs, ys);}

void MainWindow::setInitialTimeDisplay(int start){    std::size_t ncols = _vm["file.ncols"].as<int>();    std::size_t nrows = _vm["file.nrows"].as<int>();    //TODO: move plotting to appropiate method    std::size_t numofplottedsamples = _vm["plot.num.samples"].as<int>();    _gridPlot->p->detachItems();    _gridPlot->setoffset(start);    double interrowoffset = _vm["inter.row.offset"].as<double>();    for (std::size_t row=0; row<nrows; ++row){//    for (std::size_t row=0; row<1; ++row){        std::vector<double> xs(numofplottedsamples);        std::vector<double> ys(numofplottedsamples);        std::stringstream strst;        std::string strTitle = "Row";        strst << strTitle << "-" << row;        strTitle = strst.str();        QwtPlotCurve *tscurve = new QwtPlotCurve((char *)strTitle.c_str());        for (std::size_t x = 0; x < numofplottedsamples; ++x)        {            if (x+start<ncols){		    xs[x] = (x+start)/_gridPlot->gridXpixelsperunit; //position in seconds		    if (_bf!=NULL) {			    ys[x] = row*interrowoffset + (*_bf)(row,x+start)/_gridPlot->gridYpixelsperunit; //y value of that sample		    } else if (_bfsi!=NULL) {			    ys[x] = row*interrowoffset + (*_bfsi)(row,x+start)/_gridPlot->gridYpixelsperunit; //y value of that sample		    }            }        }        tscurve->setSamples(&xs[0],&ys[0],xs.size());        tscurve->setPen(QPen(Qt::black));        QwtPlotMarker *rowNameText = new QwtPlotMarker();        rowNameText->setLabel(QString(strTitle.c_str()));        rowNameText->setXValue(xs[0]+0.25);        rowNameText->setYValue(row*interrowoffset-0.5);        rowNameText->attach(_gridPlot->p);        tscurve->attach(_gridPlot->p);    }    _gridPlot->resetzoom();}

boxwide_vect_box (path ip, SI x1, SI x2, pencil pen) {    SI penw= pen->get_width ();    SI width, height, arrow= 2*penw, delta=penw/2;    get_wide_parameters (x1, x2, pen, width, height);    height= 10*penw;    array<box> bs (3);    array<SI>  xs (3);    array<SI>  ys (3);    xs[0]= ys[0]= xs[1]= ys[1]= xs[2]= ys[2]= 0;    bs[0]= line_box (decorate_middle (ip), 0, arrow, width, arrow, pen);    bs[1]= line_box (decorate_middle (ip),                     width- arrow- delta, 0, width, arrow, pen);    bs[2]= line_box (decorate_middle (ip),                     width+ delta- arrow, 2*arrow, width, arrow, pen);    return composite_box (ip, bs, xs, ys);}

 ExecStatus Distinct<View0,View1>::post(Home home, View0 x, View1 y) {   if (x.assigned()) {     GlbRanges<View0> xr(x);     IntSet xs(xr);     ConstSetView cv(home, xs);     GECODE_ES_CHECK((DistinctDoit<View1>::post(home,y,cv)));   }   if (y.assigned()) {     GlbRanges<View1> yr(y);     IntSet ys(yr);     ConstSetView cv(home, ys);     GECODE_ES_CHECK((DistinctDoit<View0>::post(home,x,cv)));   }   (void) new (home) Distinct<View0,View1>(home,x,y);   return ES_OK; }

std::vector<receiverStruct>receiver::getReceiversFromOptions(){	// get number of receivers	PetscInt numReceivers;	PetscOptionsGetInt(NULL, "--number_of_receivers", &numReceivers, NULL);	// get base directory for where to write receivers	char dumC[PETSC_MAX_PATH_LEN];	PetscOptionsGetString(NULL, "--base_write_directory", 					   	  dumC,					   	  PETSC_MAX_PATH_LEN, NULL);	std::string baseName = dumC;	PetscOptionsGetString(NULL, "--iteration_name",						  dumC, PETSC_MAX_PATH_LEN, NULL);	baseName += "/" + std::string(dumC) + "/receivers";	// make the base dir	if (MPI::COMM_WORLD.Get_rank() == 0)	{		mkdir(baseName.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);	}	// get receiver parameters	char *names[numReceivers]; PetscBool dumB = PETSC_FALSE;	std::vector<PetscScalar> xs(numReceivers);	std::vector<PetscScalar> ys(numReceivers);	PetscOptionsGetStringArray(NULL, "--receiver_names", names, &numReceivers, NULL);	PetscOptionsGetScalarArray(NULL, "--receiver_x", xs.data(), &numReceivers, NULL);	PetscOptionsGetScalarArray(NULL, "--receiver_y", ys.data(), &numReceivers, NULL);	PetscOptionsGetBool(NULL, "--write_receivers", &dumB, NULL);	// add to structures	std::vector<receiverStruct> receivers;	for (auto i=0; i<numReceivers; i++)	{		receiverStruct r;		r.name = baseName + "/" + names[i] + ".txt";		r.xLoc = xs[i];		r.yLoc = ys[i];		r.write = dumB;		receivers.push_back(r);	}	return receivers;}

boxtypeset_as_box (edit_env env, tree t, path ip) {  box b= typeset_as_concat (env, t, ip);  SI ox= 0;  int i, n=N(b);  for (i=0; i<n; i++)    if (b[i]->w() != 0)      ox= b[i]->x1;  array<box> bs (1);  array<SI>  xs (1);  array<SI>  ys (1);  bs[0]= b;  xs[0]= ox;  ys[0]= 0;  return composite_box (ip, bs, xs, ys);}

	int maxArea(vector<int>& height) {		auto comp = [&height](int a, int b) -> bool {return height[a] < height[b]; };		priority_queue<int, vector<int>, decltype(comp)> xs(comp);		REP(i, height.size()) xs.push(i);		int minx = xs.top();		int maxx = xs.top();		int ret = 0;		xs.pop();		while (!xs.empty())		{			minx = min(minx, xs.top());			maxx = max(maxx, xs.top());			ret = max(ret, (maxx - minx)*height[xs.top()]);			// cout << xs.top() << ' ' << ret << endl;			xs.pop();		}		return ret;	}

//////////////////////////////////////////////////////////////////////////////////////////////////////////get_subwindow with repeated valuescv::Mat get_subwindow(cv::Rect r, const cv::Mat & img){	std::vector<int> xs(r.width);	cv::Mat out(r.height,r.width,CV_8U);	for (int i = 0; i < r.width; i++)	{		xs[i] = r.x + i;		if (xs[i] < 0)		{			xs[i] = 0;		}		else if (xs[i] >= img.cols)		{			xs[i] = img.cols-1;		}	}	std::vector<int> ys(r.height);	for (int i = 0; i < r.height; i++)	{		ys[i] = r.y + i;		if (ys[i] < 0)		{			ys[i] = 0;		}		else if (ys[i] >= img.rows)		{			ys[i] = img.rows-1;		}	}	for (int i = 0; i < r.width; i++)	{		for (int j = 0; j < r.height; j++)		{			out.at<unsigned char>(j,i) = img.at<unsigned char>(ys[j],xs[i]);		}	}	//cv::imshow("subwindow",out.clone());	return out.clone();}

int main() {    std::vector<int> x {3,2,1,4,5,6};    vectorSubrange<int> xs(x,2,3);    std::vector<int>::iterator i = begin(xs);    std::cout << *i << " " << *(i+2) << std::endl;        constVectorSubrange<int> xss(x,2,-1);    std::vector<int>::const_iterator it = begin(xss);    std::cout << *it << " " << *(it+2) << std::endl;    for ( auto ii=begin(xss); ii!=end(xss); ++ii)        std::cout << *ii << ",";    std::cout << std::endl;    for ( auto ii : xss )        std::cout << ii << ",";    std::cout << std::endl;}

boxwide_tilda_box (path ip, SI x1, SI x2, pencil pen) {    SI width, height, w, h, uw, hh;    get_wide_parameters (x1, x2, pen, width, height);    h = height/2;    hh= (SI) (0.8660254 * ((double) h));    w = width;    uw= (SI) (((double) w) / 4.2679492);    array<box> bs (3);    array<SI>  xs (3);    array<SI>  ys (3);    xs[0]= ys[0]= xs[1]= ys[1]= xs[2]= ys[2]= 0;    bs[0]= arc_box (decorate_middle (ip),                    0, -h, 2*uw, h, 60<<6, 180<<6, pen);    bs[1]= line_box (decorate_middle (ip),                     3*uw/2, hh, w-(3*uw/2), h-hh, pen);    bs[2]= arc_box (decorate_middle (ip),                    w- (2*uw), 0, w, 2*h, 240<<6, 360<<6, pen);    return composite_box (ip, bs, xs, ys);}