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

Vector<double> Vector<T>::reduce(double factor) const {    Vector<double> vec(dimension());    std::transform(this->begin(), this->end(), vec.begin(),                   [&factor](const T &v) { return v / factor; });    return vec;}

Vector3D Vector3D::operator*(double val) const{    Vector3D vec(*this);    vec *= val;    return vec;}

float pointdistance(coordinate c1,coordinate c2) {	coordinate vec(c2.x-c1.x,c2.y-c1.y,c2.z-c1.z);	return (vec.x*vec.x+vec.y*vec.y+vec.z*vec.z);}

void LLWLParamManager::propagateParameters(void){	LL_RECORD_BLOCK_TIME(FTM_UPDATE_WLPARAM);		LLVector4 sunDir;	LLVector4 moonDir;	// set the sun direction from SunAngle and EastAngle	F32 sinTheta = sin(mCurParams.getEastAngle());	F32 cosTheta = cos(mCurParams.getEastAngle());	F32 sinPhi = sin(mCurParams.getSunAngle());	F32 cosPhi = cos(mCurParams.getSunAngle());	sunDir.mV[0] = -sinTheta * cosPhi;	sunDir.mV[1] = sinPhi;	sunDir.mV[2] = cosTheta * cosPhi;	sunDir.mV[3] = 0;	moonDir = -sunDir;	// is the normal from the sun or the moon	if(sunDir.mV[1] >= 0)	{		mLightDir = sunDir;	}	else if(sunDir.mV[1] < 0 && sunDir.mV[1] > LLSky::NIGHTTIME_ELEVATION_COS)	{		// clamp v1 to 0 so sun never points up and causes weirdness on some machines		LLVector3 vec(sunDir.mV[0], sunDir.mV[1], sunDir.mV[2]);		vec.mV[1] = 0;		vec.normVec();		mLightDir = LLVector4(vec, 0.f);	}	else	{		mLightDir = moonDir;	}	// calculate the clamp lightnorm for sky (to prevent ugly banding in sky	// when haze goes below the horizon	mClampedLightDir = sunDir;	if (mClampedLightDir.mV[1] < -0.1f)	{		mClampedLightDir.mV[1] = -0.1f;	}	mCurParams.set("lightnorm", mLightDir);	// bind the variables for all shaders only if we're using WindLight	LLViewerShaderMgr::shader_iter shaders_iter, end_shaders;	end_shaders = LLViewerShaderMgr::instance()->endShaders();	for(shaders_iter = LLViewerShaderMgr::instance()->beginShaders(); shaders_iter != end_shaders; ++shaders_iter) 	{		if (shaders_iter->mProgramObject != 0			&& (gPipeline.canUseWindLightShaders()				|| shaders_iter->mShaderGroup == LLGLSLShader::SG_WATER))		{			shaders_iter->mUniformsDirty = TRUE;		}	}	// get the cfr version of the sun's direction	LLVector3 cfrSunDir(sunDir.mV[2], sunDir.mV[0], sunDir.mV[1]);	// set direction and don't allow overriding	gSky.setSunDirection(cfrSunDir, LLVector3(0,0,0));	gSky.setOverrideSun(TRUE);}

// <int Order_s, int Order_p, int Order_t>void Convection ::initLinearOperator2( sparse_matrix_ptrtype& L ){    boost::timer ti;    LOG(INFO) << "[initLinearOperator2] start/n";    mesh_ptrtype mesh = Xh->mesh();    element_type U( Xh, "u" );    element_type Un( Xh, "un" );    element_type V( Xh, "v" );    element_0_type u = U. element<0>(); // fonction vitesse    element_0_type un = Un. element<0>(); // fonction vitesse    element_0_type v = V. element<0>(); // fonction test vitesse    element_1_type p = U. element<1>(); // fonction pression    element_1_type pn = Un. element<1>(); // fonction pression    element_1_type q = V. element<1>(); // fonction test pression    element_2_type t = U. element<2>(); // fonction temperature    element_2_type tn = Un. element<2>(); // fonction temperature    element_2_type s = V. element<2>(); // fonction test temperature#if defined( FEELPP_USE_LM )    element_3_type xi = U. element<3>(); // fonction multipliers    element_3_type eta = V. element<3>(); // fonction test multipliers#endif    double gr= M_current_Grashofs;    double sqgr( 1/math::sqrt( gr ) );    double pr = M_current_Prandtl;    double sqgrpr( 1/( pr*math::sqrt( gr ) ) );    double gamma( this->vm()["penalbc"]. as<double>() );    double k=this->vm()["k"]. as<double>();    double nu=this->vm()["nu"]. as<double>();    double rho=this->vm()["rho"]. as<double>();    //double dt=this->vm()["dt"]. as<double>();    int adim=this->vm()["adim"]. as<int>();    int weakdir=this->vm()["weakdir"]. as<int>();    //choix de la valeur des paramètres dimensionnés ou adimensionnés    double a=0.0,b=0.0,c=0.0;    double pC=1;    if ( adim == 0 ) pC = this->vm()["pC"]. as<double>();    if ( adim==1 )    {        a=1;        b=sqgr;        c=sqgrpr;    }    else    {        a=rho;        b=nu;        c=k;    }    double expansion = 1;    if ( adim == 0 ) expansion=3.7e-3;    auto bf = form2( _test=Xh, _trial=Xh, _matrix=L );    // Temperature#if CONVECTION_DIM==2    // buyoancy forces c(theta,v)    bf +=integrate( _range=elements( mesh ),                    _expr=-expansion*idt( t )*( trans( vec( constant( 0. ),constant( 1.0 ) ) )*id( v ) ) );#else    bf +=integrate( _range=elements( mesh ),                    _expr=-expansion*idt( t )*( trans( vec( cst(0.), constant( 0. ),constant( 1.0 ) ) )*id( v ) ) );#endif    LOG(INFO) << "[initLinearOperator] temperature Force terms done/n";    // heat conduction/diffusion: e(beta1,theta,chi)+f(theta,chi)    bf  += integrate( _range=elements( mesh ),                      _expr=cst( c )*gradt( t )*trans( grad( s ) ) );    LOG(INFO) << "[initLinearOperator] Temperature Diffusion terms done/n";    if ( weakdir == 1 )    {        // weak Dirichlet on temperature (T=0|left wall)        bf  += integrate ( markedfaces( mesh, "Tfixed"  ),                           - gradt( t )*N()*id( s )*cst_ref( sqgrpr ) );        bf  += integrate ( markedfaces( mesh, "Tfixed"  ),                           - grad( s )*N()*idt( t )*cst_ref( sqgrpr ) );        bf  += integrate ( markedfaces( mesh, "Tfixed"  ),                           gamma*idt( t )*id( s )/hFace() );    }    LOG(INFO) << "[initLinearOperator2] done in " << ti.elapsed() << "s/n";}

vec add(vec a, vec b){    return vec(a.x + b.x, a.y + b.y);}

 virtual Vector normal(Point) const {     return vec(vertices[1] - vertices[0], vertices[2] - vertices[0]).normalized(); }

std::ostream& operator<<(std::ostream& os, const Eigen::VectorXd &vec){  os << "[";  for (int dim = 0; dim < vec.rows(); ++dim)  {    os << std::setiosflags(std::ios::left) << std::setw(12) << std::setprecision(5) << vec(dim);  }  os << "]/n";  return os;}

//.........这里部分代码省略.........        vertexStarts[subMeshIndex] = vertexStart;                // Ogre may have multiple buffers in one submesh. These will be merged into one        XMLElement bufferDef;        if (geometry)            bufferDef = geometry.GetChild("vertexbuffer");                while (bufferDef)        {            if (bufferDef.HasAttribute("positions"))                vBuf->elementMask_ |= MASK_POSITION;            if (bufferDef.HasAttribute("normals"))                vBuf->elementMask_ |= MASK_NORMAL;            if (bufferDef.HasAttribute("texture_coords"))            {                vBuf->elementMask_ |= MASK_TEXCOORD1;                if (bufferDef.GetInt("texture_coords") > 1)                    vBuf->elementMask_ |= MASK_TEXCOORD2;            }                        unsigned vertexNum = vertexStart;            if (vertices)            {                XMLElement vertex = bufferDef.GetChild("vertex");                while (vertex)                {                    XMLElement position = vertex.GetChild("position");                    if (position)                    {                        // Convert from right- to left-handed                        float x = position.GetFloat("x");                        float y = position.GetFloat("y");                        float z = position.GetFloat("z");                        Vector3 vec(x, y, -z);                                                vBuf->vertices_[vertexNum].position_ = vec;                        boundingBox_.Merge(vec);                    }                    XMLElement normal = vertex.GetChild("normal");                    if (normal)                    {                        // Convert from right- to left-handed                        float x = normal.GetFloat("x");                        float y = normal.GetFloat("y");                        float z = normal.GetFloat("z");                        Vector3 vec(x, y, -z);                                                vBuf->vertices_[vertexNum].normal_ = vec;                    }                    XMLElement uv = vertex.GetChild("texcoord");                    if (uv)                    {                        float x = uv.GetFloat("u");                        float y = uv.GetFloat("v");                        Vector2 vec(x, y);                                                vBuf->vertices_[vertexNum].texCoord1_ = vec;                                                if (vBuf->elementMask_ & MASK_TEXCOORD2)                        {                            uv = uv.GetNext("texcoord");                            if (uv)                            {                                float x = uv.GetFloat("u");                                float y = uv.GetFloat("v");                                Vector2 vec(x, y);

void mdltrans(float *x, float *y, float *z){    checkmdl;    loadingmodel->translate = vec(*x, *y, *z);} 

void mdlextendbb(float *x, float *y, float *z){    checkmdl;    loadingmodel->bbextend = vec(*x, *y, *z);}

int main(){    std::vector<int> vec(10);    std::array_view<int, 1> b(vec);    int a = b[{100}];}

bool ofxCalibImage::makeFromImage(CVD::Image<CVD::byte> &im, ofxDataPackege * _data){    data = _data;    mvCorners.clear();    mvGridCorners.clear();        mim = im;    mim.make_unique();        // Find potential corners..    // This works better on a blurred image, so make a blurred copy    // and run the corner finding on that.    {        CVD::Image<CVD::byte> imBlurred = mim;        imBlurred.make_unique();        CVD::convolveGaussian(imBlurred, data->BlurSigma);        CVD::ImageRef irTopLeft(5,5);        CVD::ImageRef irBotRight = mim.size() - irTopLeft;        CVD::ImageRef ir = irTopLeft;                ofSetColor(255, 0, 255);        int nGate = data->MeanGate;        ofPushStyle();        ofNoFill();        do            if( IsCorner(imBlurred, ir, nGate)){                mvCorners.push_back(ir);                ofCircle(ir.x,ir.y, 2);            }        while( ir.next(irTopLeft, irBotRight));        ofPopStyle();    }        // If there's not enough corners, i.e. camera pointing somewhere random, abort.    if((int) mvCorners.size() < 20)        return false;        // Pick a central corner point...    CVD::ImageRef irCenterOfImage = mim.size()  / 2;    CVD::ImageRef irBestCenterPos;    unsigned int nBestDistSquared = 99999999;    for(unsigned int i=0; i<mvCorners.size(); i++){        unsigned int nDist = (mvCorners[i] - irCenterOfImage).mag_squared();        if(nDist < nBestDistSquared){            nBestDistSquared = nDist;            irBestCenterPos = mvCorners[i];        }    }        // ... and try to fit a corner-patch to that.    PTAMM::CalibCornerPatch Patch( data->CornerPatchSize);    PTAMM::CalibCornerPatch::Params Params;    Params.v2Pos = vec(irBestCenterPos);    Params.v2Angles = GuessInitialAngles(mim, irBestCenterPos);     Params.dGain = 80.0;    Params.dMean = 120.0;        if(!Patch.IterateOnImageWithDrawing(Params, mim))        return false;        // The first found corner patch becomes the origin of the detected grid.    ofxCalibGridCorner cFirst;    cFirst.Params = Params;    mvGridCorners.push_back(cFirst);    cFirst.draw();        // Next, go in two compass directions from the origin patch, and see if     // neighbors can be found.    if(!(expandByAngle(0,0) || expandByAngle(0,2)))        return false;    if(!(expandByAngle(0,1) || expandByAngle(0,3)))        return false;        mvGridCorners[1].mInheritedSteps = mvGridCorners[2].mInheritedSteps = mvGridCorners[0].GetSteps(mvGridCorners);        // The three initial grid elements are enough to find the rest of the grid.    int nNext;    int nSanityCounter = 0; // Stop it getting stuck in an infinite loop...    const int nSanityCounterLimit = 500;    while((nNext = nextToExpand()) >= 0 && nSanityCounter < nSanityCounterLimit ){        expandByStep(nNext);        nSanityCounter++;    }    if(nSanityCounter == nSanityCounterLimit)        return false;        drawImageGrid();    return true;}

 static vec add(vec a, vec b) {   return vec(a.x+b.x, a.y+b.y, a.z+b.z, a.r+b.r, a.g+b.g, a.b+b.b); }

vec scale(vec v, double k){    return vec(v.x * k, v.y * k);}

vector<pair<int, float> > User::sort() {  vector<pair<int, float> > vec(*((vector<pair<int, float> >*)this));  std::sort(vec.begin(), vec.end(), hash_sort_comp());  return vec;}

vec vec_angle(double angle, double distance){    angle = angle * M_PI * 2.0 / full_circle;    return vec(cos(angle) * distance, sin(angle) * distance);}

//.........这里部分代码省略.........                {                    tmp[i] = attribute->fNumericDef[i];                }                if (attribute->fSize == 3) tmp[3] = 1.0;                // Find the coordinate space, and whether it is a point or a vector                int base = cgfxAttrDef::kAttrTypeFirstPos;                if (attribute->fType <= cgfxAttrDef::kAttrTypeLastDir)                     base = cgfxAttrDef::kAttrTypeFirstDir;                int space = attribute->fType - base;                // Compute the transform matrix                MMatrix mat;                switch (space)                {                    /* case 0:	object space, handled in view dependent method */                case 1:	/* world space  - do nothing, identity */ break;                    /* case 2: eye space, unsupported yet */                    /* case 3: clip space, unsupported yet */                    /* case 4: screen space, unsupported yet */                }                if ( base == cgfxAttrDef::kAttrTypeFirstPos )                {                    MPoint point(tmp[0], tmp[1], tmp[2], tmp[3]);                    point *= mat;                    tmp[0] = point.x;                    tmp[1] = point.y;                    tmp[2] = point.z;                    tmp[3] = point.w;                }                else                {                    MVector vec(tmp[0], tmp[1], tmp[2]);                    vec *= mat;                    tmp[0] = vec.x;                    tmp[1] = vec.y;                    tmp[2] = vec.z;                    tmp[3] = 1;                }                COLLADASW::SetParamFloat4 setParam ( streamWriter );                setParam.openParam ( attributeName );                setParam.appendValues( tmp[0], tmp[1], tmp[2], tmp[3] );                setParam.closeParam();                break;            }        case cgfxAttrDef::kAttrTypeMatrix:        case cgfxAttrDef::kAttrTypeWorldMatrix:        case cgfxAttrDef::kAttrTypeViewMatrix:        case cgfxAttrDef::kAttrTypeProjectionMatrix:        case cgfxAttrDef::kAttrTypeWorldViewMatrix:        case cgfxAttrDef::kAttrTypeWorldViewProjectionMatrix:            {                COLLADASW::SetParamFloat4x4 setParam ( streamWriter );                setParam.openParam ( attributeName );                MMatrix mayaMatrix;                double* p = &mayaMatrix.matrix[0][0];                for ( int k=0; k<attribute->fSize; ++k )                {                    p[k] = attribute->fNumericDef[k];                }                MMatrix wMatrix, vMatrix, pMatrix, sMatrix;                MMatrix wvMatrix, wvpMatrix, wvpsMatrix;

static inline void findnormal(const normalgroup &g, const vec &surface, vec &v){    v = vec(0, 0, 0);    int total = 0;    if(surface.x >= lerpthreshold) { int n = (g.flat>>4)&0xF; v.x += n; total += n; }

int CLocalFinderApp::Run(void){    CArgs myargs = GetArgs();    int left            = myargs["from"].AsInteger();    int right           = myargs["to"].AsInteger();    bool repeats        = myargs["rep"];    //    // read our sequence data    //    CFastaReader fastareader(myargs["input"].AsString());    CRef<CSeq_loc> masked_regions;    masked_regions = fastareader.SaveMask();    CRef<CSeq_entry> se = fastareader.ReadOneSeq();        if(masked_regions) {        CBioseq& bioseq = se->SetSeq();     // assumes that reader gets only one sequence per fasta id (no [] in file)        CRef<CSeq_annot> seq_annot(new CSeq_annot);        seq_annot->SetNameDesc("NCBI-FASTA-Lowercase");        bioseq.SetAnnot().push_back(seq_annot);        CSeq_annot::C_Data::TFtable* feature_table = &seq_annot->SetData().SetFtable();        for(CSeq_loc_CI i(*masked_regions); i; ++i) {            CRef<CSeq_feat> repeat(new CSeq_feat);            CRef<CSeq_id> id(new CSeq_id);            id->Assign(i.GetSeq_id());            CRef<CSeq_loc> loc(new CSeq_loc(*id, i.GetRange().GetFrom(), i.GetRange().GetTo()));            repeat->SetLocation(*loc);            repeat->SetData().SetImp().SetKey("repeat_region");            feature_table->push_back(repeat);        }    }    CRef<CObjectManager> objmgr = CObjectManager::GetInstance();    CScope scope(*objmgr);    scope.AddTopLevelSeqEntry(*se);           CRef<CSeq_id> cntg(new CSeq_id);    cntg->Assign(*se->GetSeq().GetFirstId());    CSeq_loc loc;    loc.SetWhole(*cntg);    CSeqVector vec(loc, scope);    vec.SetIupacCoding();    CResidueVec seq;    ITERATE(CSeqVector,i,vec)        seq.push_back(*i);    // read the alignment information    TGeneModelList alignments;    if(myargs["align"]) {        CNcbiIstream& alignmentfile = myargs["align"].AsInputFile();        string our_contig = cntg->GetSeqIdString(true);        string cur_contig;         CAlignModel algn;                while(alignmentfile >> algn >> getcontig(cur_contig)) {            if (cur_contig==our_contig)                alignments.push_back(algn);        }    }    // create engine    CRef<CHMMParameters> hmm_params(new CHMMParameters(myargs["model"].AsInputFile()));    CGnomonEngine gnomon(hmm_params, seq, TSignedSeqRange(left, right));    // run!    gnomon.Run(alignments, repeats, true, true, false, false, 10.0);    // dump the annotation    CRef<CSeq_annot> annot = gnomon.GetAnnot(*cntg);    auto_ptr<CObjectOStream> os(CObjectOStream::Open(eSerial_AsnText, cout));    *os << *annot;    return 0;}

void CaveV6::makeTunnel(bool dirswitch) {	if (dirswitch && !large_cave) {		main_direction = v3f(			((float)(ps->next() % 20) - (float)10) / 10,			((float)(ps->next() % 20) - (float)10) / 30,			((float)(ps->next() % 20) - (float)10) / 10		);		main_direction *= (float)ps->range(0, 10) / 10;	}	// Randomize size	s16 min_d = min_tunnel_diameter;	s16 max_d = max_tunnel_diameter;	rs = ps->range(min_d, max_d);	v3s16 maxlen;	if (large_cave) {		maxlen = v3s16(			rs * part_max_length_rs,			rs * part_max_length_rs / 2,			rs * part_max_length_rs		);	} else {		maxlen = v3s16(			rs * part_max_length_rs,			ps->range(1, rs * part_max_length_rs),			rs * part_max_length_rs		);	}	v3f vec(		(float)(ps->next() % (maxlen.X * 1)) - (float)maxlen.X / 2,		(float)(ps->next() % (maxlen.Y * 1)) - (float)maxlen.Y / 2,		(float)(ps->next() % (maxlen.Z * 1)) - (float)maxlen.Z / 2	);	// Jump downward sometimes	if (!large_cave && ps->range(0, 12) == 0) {		vec = v3f(			(float)(ps->next() % (maxlen.X * 1)) - (float)maxlen.X / 2,			(float)(ps->next() % (maxlen.Y * 2)) - (float)maxlen.Y,			(float)(ps->next() % (maxlen.Z * 1)) - (float)maxlen.Z / 2		);	}	vec += main_direction;	v3f rp = orp + vec;	if (rp.X < 0)		rp.X = 0;	else if (rp.X >= ar.X)		rp.X = ar.X - 1;		if (rp.Y < route_y_min)		rp.Y = route_y_min;	else if (rp.Y >= route_y_max)		rp.Y = route_y_max - 1;		if (rp.Z < 0)		rp.Z = 0;	else if (rp.Z >= ar.Z)		rp.Z = ar.Z - 1;		vec = rp - orp;	float veclen = vec.getLength();	// As odd as it sounds, veclen is *exactly* 0.0 sometimes, causing a FPE	if (veclen < 0.05)		veclen = 1.0;			// Every second section is rough	bool randomize_xz = (ps2->range(1, 2) == 1);	// Carve routes	for (float f = 0; f < 1.0; f += 1.0 / veclen)		carveRoute(vec, f, randomize_xz);		orp = rp;}

 void clearloc() { loc = vec(-1e16f, -1e16f, -1e16f); }

RealNSMomentumInviscidFluxWithGradP::computeQpOffDiagJacobian(unsigned int jvar){  // Map jvar into the numbering expected by this->compute_pressure_jacobain_value()  unsigned var_number = this->map_var_number(jvar);  // The Jacobian contribution due to differentiating the grad(p)  // term wrt variable var_number.  Real dFdp = compute_pressure_jacobian_value(var_number);  if (jvar == _rho_var_number)  {    // Derivative of inviscid flux convective terms wrt density:    // x-mom: (-u_1^2   , -u_1*u_2  , -u_1*u_3 ) * grad(phi_i) * phi_j    // y-mom: (-u_2*u_1 , -u_2^2    , -u_2*u_3 ) * grad(phi_i) * phi_j    // z-mom: (-u_3*u_1 , -u_3*u_2  , -u_3^2   ) * grad(phi_i) * phi_j    // Start with the velocity vector    RealVectorValue vec(_u_vel[_qp], _v_vel[_qp], _w_vel[_qp]);    // Scale velocity vector by -1 * vec(_component)    vec *= -vec(_component);    return      // Convective terms Jacobian      -(vec * _grad_test[_i][_qp]) * _phi[_j][_qp]      +      // Pressure term Jacobian      dFdp*_test[_i][_qp];  }  // Handle off-diagonal derivatives wrt momentums  else if ((jvar == _rhou_var_number) || (jvar == _rhov_var_number) || (jvar == _rhow_var_number))  {    // Start with the velocity vector    RealVectorValue vel(_u_vel[_qp], _v_vel[_qp], _w_vel[_qp]);    // Map jvar into jlocal = {0,1,2}, regardless of how Moose has numbered things.    // Can't do a case statement here since _rhou_var_number, etc. are not constants...    unsigned jlocal = 0;    if (jvar == _rhov_var_number)      jlocal = 1;    else if (jvar == _rhow_var_number)      jlocal = 2;    return      // Convective terms Jacobian      -vel(_component) * _grad_test[_i][_qp](jlocal) * _phi[_j][_qp]      +      // Pressure term Jacobian      dFdp*_test[_i][_qp];  }  else if (jvar == _rhoe_var_number)  {    return      // Pressure term Jacobian      dFdp*_test[_i][_qp];  }  // We shouldn't get here... jvar should have matched one of the if statements above!  mooseError("computeQpOffDiagJacobian called with invalid jvar.");  return 0;}

expression_ptr cpp_from_cloog::process( clast_expr* expr ){    switch(expr->type)    {    case clast_expr_name:    {        string name = reinterpret_cast<clast_name*>(expr)->name;        if (m_id_func)        {            auto expr = m_id_func(name);            if (expr)                return expr;        }        return make_shared<id_expression>(name);    }    case clast_expr_term:    {        auto term = reinterpret_cast<clast_term*>(expr);        expression_ptr val = literal(term->val);        if (term->var)        {            auto var = process(term->var);            val = make_shared<bin_op_expression>(op::mult, val, var);        }        return val;    }    case clast_expr_bin:    {        auto operation = reinterpret_cast<clast_binary*>(expr);        auto lhs = process(operation->LHS);        auto rhs = literal(operation->RHS);        cpp_gen::op op_type;        switch(operation->type)        {        case clast_bin_fdiv:            throw std::runtime_error("Floor-of-division not implemented.");        case clast_bin_cdiv:            throw std::runtime_error("Ceiling-of-division not implemented.");        case clast_bin_div:            op_type = op::div;        case clast_bin_mod:            // FIXME: should be modulo, not remainder!            op_type = op::rem;        default:            throw std::runtime_error("Unexpected binary operation type.");        }        return make_shared<bin_op_expression>(op_type, lhs, rhs);    }    case clast_expr_red:    {        auto reduction = reinterpret_cast<clast_reduction*>(expr);        if (reduction->n < 1)            return literal((long)0);        auto lhs = process( reduction->elts[0] );        for (int i = 1; i < reduction->n; ++i)        {            auto rhs = process( reduction->elts[i] );            switch(reduction->type)            {            case clast_red_sum:                lhs = make_shared<bin_op_expression>(op::add, lhs, rhs);                break;            case clast_red_min:                lhs = make_shared<call_expression>("min", vec({lhs, rhs}));                break;            case clast_red_max:                lhs = make_shared<call_expression>("max", vec({lhs, rhs}));                break;            default:                throw std::runtime_error("Unexpected reduction type.");            }        }        return lhs;    }    default:        throw std::runtime_error("Unexpected expression type.");    }}

void ofxCalibImage::expandByStep(int n){    //static gvar3<double> gvdMaxStepDistFraction("CameraCalibrator.ExpandByStepMaxDistFrac", 0.3, SILENT);    //static gvar3<int> gvnCornerPatchSize("CameraCalibrator.CornerPatchPixelSize", 20, SILENT);        ofxCalibGridCorner &gSrc = mvGridCorners[n];        // First, choose which direction to expand in...    // Ideally, choose a dirn for which the Step calc is good!    int nDirn = -10;    for(int i=0; nDirn == -10 && i<4; i++){        if(gSrc.aNeighborStates[i].val == N_NOT_TRIED &&           gSrc.aNeighborStates[(i+2) % 4].val >= 0)            nDirn = i;    }    if(nDirn == -10)        for(int i=0; nDirn == -10 && i<4; i++){            if(gSrc.aNeighborStates[i].val == N_NOT_TRIED)                nDirn = i;        }    assert(nDirn != -10);        TooN::Vector<2> v2Step;    CVD::ImageRef irGridStep = ir_from_dirn(nDirn);        v2Step = gSrc.GetSteps(mvGridCorners).T() * vec(irGridStep);        TooN::Vector<2> v2SearchPos = gSrc.Params.v2Pos + v2Step;        // Before the search: pre-fill the failure result for easy returns.    gSrc.aNeighborStates[nDirn].val = N_FAILED;        CVD::ImageRef irBest;    double dBestDist = 99999;    for(unsigned int i=0; i<mvCorners.size(); i++){        TooN::Vector<2> v2Diff = vec(mvCorners[i]) - v2SearchPos;        if( (v2Diff * v2Diff) > (dBestDist * dBestDist) )            continue;        dBestDist = sqrt(v2Diff * v2Diff);        irBest = mvCorners[i];    }        double dStepDist= sqrt(v2Step * v2Step);    if(dBestDist > data->MaxStepDistFraction * dStepDist)        return;        ofxCalibGridCorner gTarget;    gTarget.Params = gSrc.Params;    gTarget.Params.v2Pos = vec(irBest);    gTarget.Params.dGain *= -1;    gTarget.irGridPos = gSrc.irGridPos + irGridStep;    gTarget.mInheritedSteps = gSrc.GetSteps(mvGridCorners);    PTAMM::CalibCornerPatch Patch( data->CornerPatchSize);    if(!Patch.IterateOnImageWithDrawing(gTarget.Params, mim))        return;        // Update connection states:    int nTargetNum = static_cast<int>(mvGridCorners.size());    for(int dirn = 0; dirn<4; dirn++){        CVD::ImageRef irSearch = gTarget.irGridPos + ir_from_dirn(dirn);        for(unsigned int i=0; i<mvGridCorners.size(); i++)            if(mvGridCorners[i].irGridPos == irSearch){                gTarget.aNeighborStates[dirn].val = i;                mvGridCorners[i].aNeighborStates[(dirn + 2) % 4].val = nTargetNum;            }    }    mvGridCorners.push_back(gTarget);    mvGridCorners.back().draw();}

//////////////////////////////////////////////////////////////// Used to handle direct messages into the table, or// returned plot data from queried objects.//////////////////////////////////////////////////////////////void Table::input( double v ){    vec().push_back( v );}

int MapgenMath::generateTerrain() {	MapNode n_air(CONTENT_AIR, LIGHT_SUN), n_water_source(c_water_source, LIGHT_SUN);	MapNode n_stone(c_stone, LIGHT_SUN);	u32 index = 0;	v3s16 em = vm->m_area.getExtent();#if 1	/* debug	v3f vec0 = (v3f(node_min.X, node_min.Y, node_min.Z) - center) * scale ;	errorstream << " X=" << node_min.X << " Y=" << node_min.Y << " Z=" << node_min.Z	            //<< " N="<< mengersponge(vec0.X, vec0.Y, vec0.Z, distance, iterations)	            << " N=" << (*func)(vec0.X, vec0.Y, vec0.Z, distance, iterations)	            << " Sc=" << scale << " gen=" << params["generator"].asString() << " J=" << Json::FastWriter().write(params) << std::endl;	*/	for (s16 z = node_min.Z; z <= node_max.Z; z++) {		for (s16 x = node_min.X; x <= node_max.X; x++, index++) {			Biome *biome = bmgr->biomes[biomemap[index]];			u32 i = vm->m_area.index(x, node_min.Y, z);			for (s16 y = node_min.Y; y <= node_max.Y; y++) {				v3f vec = (v3f(x, y, z) - center) * scale ;				double d = (*func)(vec.X, vec.Y, vec.Z, distance, iterations);				if ((!invert && d > 0) || (invert && d == 0)  ) {					if (vm->m_data[i].getContent() == CONTENT_IGNORE)	//					vm->m_data[i] = (y > water_level + biome->filler) ?		//				                MapNode(biome->c_filler) : n_stone;						vm->m_data[i] = n_stone;				} else if (y <= water_level) {					vm->m_data[i] = n_water_source;				} else {					vm->m_data[i] = n_air;				}				vm->m_area.add_y(em, i, 1);			}		}	}#endif#if 0// mandelbulber, unfinished but works	sFractal par;	par.doubles.N = 10;	par.doubles.power = 9.0;	par.doubles.foldingSphericalFixed =  1.0;	par.doubles.foldingSphericalMin = 0.5;	//no par.formula = smoothMandelbox; par.doubles.N = 40; invert = 0;//no	par.mandelbox.doubles.sharpness = 3.0;	par.mandelbox.doubles.scale = 1;	par.mandelbox.doubles.sharpness = 2;	par.mandelbox.doubles.foldingLimit = 1.0;	par.mandelbox.doubles.foldingValue = 2;//ok	par.formula = mandelboxVaryScale4D; par.doubles.N = 50; scale = 5; invert = 1; //ok	par.mandelbox.doubles.vary4D.scaleVary =  0.1;	par.mandelbox.doubles.vary4D.fold = 1;	par.mandelbox.doubles.vary4D.rPower = 1;	par.mandelbox.doubles.vary4D.minR = 0.5;	par.mandelbox.doubles.vary4D.wadd = 0;	par.doubles.constantFactor = 1.0;	par.formula = menger_sponge; par.doubles.N = 15; invert = 0; size = 30000; center = v3f(-size / 2, -size + (-2 * -invert), 2);  scale = (double)1 / size; //ok	//double tresh = 1.5;	//par.formula = mandelbulb2; par.doubles.N = 10; scale = (double)1/size; invert=1; center = v3f(5,-size-5,0); //ok	//par.formula = hypercomplex; par.doubles.N = 20; scale = 0.0001; invert=1; center = v3f(0,-10001,0); //(double)50 / max_r;	//no par.formula = trig_DE; par.doubles.N = 5;  scale = (double)10; invert=1;	//no par.formula = trig_optim; scale = (double)10;  par.doubles.N = 4;	//par.formula = mandelbulb2; scale = (double)1/10000; par.doubles.N = 10; invert = 1; center = v3f(1,-4201,1); //ok	// no par.formula = tglad;	//par.formula = xenodreambuie;  par.juliaMode = 1; par.doubles.julia.x = -1; par.doubles.power = 2.0; center=v3f(-size/2,-size/2-5,5); //ok	par.mandelbox.doubles.vary4D.scaleVary = 0.1;	par.mandelbox.doubles.vary4D.fold = 1;	par.mandelbox.doubles.vary4D.minR = 0.5;	par.mandelbox.doubles.vary4D.rPower = 1;	par.mandelbox.doubles.vary4D.wadd = 0;	//no par.formula = mandelboxVaryScale4D;	par.doubles.cadd = -1.3;	//par.formula = aexion; // ok but center	//par.formula = benesi; par.doubles.N = 10; center = v3f(0,0,0); invert = 0; //ok	// par.formula = bristorbrot; //ok	v3f vec0(node_min.X, node_min.Y, node_min.Z);	vec0 = (vec0 - center) * scale ;	errorstream << " X=" << node_min.X << " Y=" << node_min.Y << " Z=" << node_min.Z	            << " N=" << Compute<normal>(CVector3(vec0.X, vec0.Y, vec0.Z), par)	            //<<" F="<< Compute<fake_AO>(CVector3(node_min.X,node_min.Y,node_min.Z), par)	            //<<" L="<<node_min.getLength()<< " -="<<node_min.getLength() - Compute<normal>(CVector3(node_min.X,node_min.Y,node_min.Z), par)	            << " Sc=" << scale	            << std::endl;	for (s16 z = node_min.Z; z <= node_max.Z; z++)//.........这里部分代码省略.........