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

Value* Pair(Value* h, Value* t, EnvironmentFrame* env, Allocator* a){    gcguard<Value> head = Eval(h, env);    gcguard<Value> tail = Eval(t, env);    return a->allocate<ConsPair>(head.ptr(), tail.ptr());}

int main(int argc, char *argv[]) {    printf("/n");    if (argc < 2) {        printf("not enough arguments/n/n");        return 1;    }    printf("STARTING MATLAB ENGINE/n/n");    Engine *ep = engOpen("");    if (ep == NULL) {        printf("unable to start MATLAB engine/n/n");        return 1;    }    engSetVisible(ep, false);    char out[BUFSIZE];    engOutputBuffer(ep, out, BUFSIZE);    printf("SETTING PATH TO CNS/n/n");    Eval(ep, out, "run(fullfile('%s', 'cns_path'));", argv[1]);    bool ok = RunDemo(ep, out);    printf("PRESS RETURN TO CONTINUE: ");    fgets(out, BUFSIZE, stdin);    printf("/n");    printf("CLOSING MATLAB ENGINE/n/n");    Eval(ep, out, "close all;");    engClose(ep);    return ok ? 0 : 1;}

void CEvaluatingFunction::generatePoints(COUNTER FitCaseNum){		F<double> IntervalSize = (RangeMax-RangeMin)/(double)FitCaseNum;		destroyPoints();		try{			FunctionX1.push_back(RangeMin);			FunctionY.push_back(Eval(RangeMin));			for(COUNTER i=1; i<FitCaseNum-1; i++){							F<double> x = RangeMin + ((F<double>)i*IntervalSize);	//Pick a point 				int somewhere = rand()%100;		//in the interval,				if (somewhere) x+= ((F<double>)1.0f/(F<double>)(somewhere))*IntervalSize;	//somewhere in the interval.							FunctionX1.push_back(x);				FunctionY.push_back(Eval(x));			}			FunctionX1.push_back(RangeMax);			FunctionY.push_back(Eval(RangeMax));		}		catch(CString Exc){			throw Exc;		}}

double ExplicitCurve2d :: NumericalProjectParam (const Point<2> & p, double lb, double ub) const  {  double t(-1);  Vec<2> tan;  Vec<2> curv;  Point<2> cp;  double f, fl, fu;  int cnt;    tan = EvalPrime (lb);  cp = Eval (lb);  fl = tan * (cp - p);  if (fl > 0)			// changed by wmf, originally fl >= 0    {      //      cerr << "tan = " << tan << " cp - p = " << (cp - p) << endl;      //      cerr << "ExplicitCurve2d::NumericalProject: lb wrong" << endl;      return 0;    }    tan = EvalPrime (ub);  cp = Eval (ub);  fu = tan * (cp - p);  if (fu < 0)			// changed by wmf, originally fu <= 0    {      //    cerr << "tan = " << tan << " cp - p = " << (cp - p) << endl;      //    cerr << "ExplicitCurve2d::NumericalProject: ub wrong" << endl;    return 0;    }      cnt = 0;  while (ub - lb > 1e-12 && fu - fl > 1e-12)    {    cnt++;    if (cnt > 50)      {      (*testout) << "Num Proj, cnt = " << cnt << endl;      }         t = (lb * fu - ub * fl) / (fu - fl);    if (t > 0.9 * ub + 0.1 * lb) t = 0.9 * ub + 0.1 * lb;    if (t < 0.1 * ub + 0.9 * lb) t = 0.1 * ub + 0.9 * lb;        tan = EvalPrime (t);    cp = Eval (t);    f = tan * (cp - p);        if (f >= 0)      {      ub = t;      fu = f;      }    else      {      lb = t;      fl = f;      }    }      return t;  }

static bool controlExpression(char relOp, expADT expL, expADT expR, environmentADT env){	valueADT leftV, rightV;	leftV = Eval(expL, env);	rightV = Eval(expR, env);	if(ValueType(leftV) == IntValue && ValueType(rightV) == IntValue ){		switch(relOp){		case '<':		return (GetIntValue(leftV) < GetIntValue(rightV));		case '>':			return (GetIntValue(leftV) > GetIntValue(rightV));		case '=':			return (GetIntValue(leftV) == GetIntValue(rightV));		default:			Error("Reloperator %c is not valid./n", relOp);			break;		}	}	else		Error("/nCompared expressions is not Integers/n");}

void Unset(Var x){	if(SymQ(x))	{		OwnValues.erase(x);		return;	}	if(VecQ(x))	{		size_t n = Size(x);		for(size_t i = 0; i < n; ++i)			Unset(At(x,i));		return;	}	if(ExQ(x))	{		var h = Eval(Head(x));		if(SymQ(h))		{			var b = Body(x);			if(h == TAG(Property))			{				if(SymQ(At(b,0)) && SymQ(At(b,1)))				{					std::map<Var,map_t>::iterator						iter = Properties.find(At(b,0));					if(iter != Properties.end())						iter->second.erase(At(b,1));				}				return;			}			b = Eval(b);			if(FixQ(b))			{				std::map<Var,dict_t>::iterator					iter = FactValues.find(h);				if(iter != FactValues.end())					iter->second.erase(b);			}			else			{				std::map<Var,def_t>::iterator					iter = DownValues.find(h);				if(iter != DownValues.end())					iter->second.erase(b);			}			return;		}		else if(ExQ(h) && SymQ(Head(h)))		{			var b = Eval(Body(x));			var t = Vec(Body(h),b);			std::map<Var,def_t>::iterator				iter = SubValues.find(Head(h));			if(iter != SubValues.end())					iter->second.erase(t);			return;		}	}}

int Minimax::Quiescence(Board *board, GameInfo *gameInfo, int depth, int alpha, int beta) {	// Evaluate the node in its current state. If it causes a beta-cutoff, assume that there will be no move further down the	//game tree that will result in a better evaluation. Otherwise, set it as the lower bound, alpha.	int nodeEvaluation = Eval(board, gameInfo);	if (nodeEvaluation >= beta) return beta;	if (nodeEvaluation > alpha) alpha = nodeEvaluation;	MoveList moveList;	// If the node is in check, consider every move. Otherwise, just consider captures/promotions.	moveList.generate(gameInfo->turn, board, gameInfo, !MoveList::InCheck(gameInfo->turn, board));	moveList.prune((Piece::Color)!gameInfo->turn, board);	for (MoveList::iterator moveItr = moveList.begin(); moveItr != moveList.end(); moveItr++) {		Move move = *moveItr;		board->executeMove(move);		// Save any irreversible game info before making a move.		GameInfo::Irreversible irreversible(gameInfo);		gameInfo->executeMove(move);		int childEval = 0;		// If we are at depth 0, just get the score of the board (The score is negated as it is measured relative to the opposite color).		if (depth == 0) childEval = -Eval(board, gameInfo);		else childEval = -Quiescence(board, gameInfo, depth - 1, -beta, -alpha);		board->reverseMove(move);		gameInfo->reverseMove(irreversible);		if (childEval >= beta) return beta;		if (childEval > alpha) alpha = childEval;	}	return alpha;}

double MyParser::EvalRemoveSingularity(double *xvar){	try {		double result = Eval();		if ( gsl_isinf(result) || gsl_isnan(result) )			throw Singularity();		return result;	} catch (Singularity) {		try {			if (isinf(Eval()))				throw Pole();			int n;			frexp (*xvar, &n);			double xp = *xvar + ldexp(DBL_EPSILON,n);			double xm = *xvar - ldexp(DBL_EPSILON,n);			*xvar = xp;			double yp = Eval();			if (gsl_isinf(yp) || gsl_isnan(yp))				throw Pole();			*xvar = xm;			double ym = Eval();			if (gsl_isinf(ym) || gsl_isnan(ym))				throw Pole();			return (yp + ym)/2;		} catch (Pole) {			SingularityErrorMessage(*xvar);			return GSL_ESING;		}	}}

double TrPdf::Integral(double xlow, double xhig) {	  if (xlow<GetX(0)) {    if (VERBOSE) printf("TrPdf::Integral-V xlow out of bounds, using low edge./n");    xlow = GetX(0);  }  if (xhig>GetX(GetN()-1)) {    if (VERBOSE) printf("TrPdf::Integral-V xhigh out of bounds, using upper edge./n");    xhig = GetX(GetN()-1);  }  if (xlow>=xhig) {    if (VERBOSE) printf("TrPdf::Integral-V xlow greater-equal than xhig, returning 0./n");    return 0.;  }  double sum = 0.;  double y1,y0,x1,x0;  for (int i=0; i<GetN()-1; i++) {    if      (xlow<=GetX(i))   { x0 = GetX(i);   y0 = GetY(i);    }    else if (xlow>=GetX(i+1)) { x0 = GetX(i+1); y0 = GetY(i+1);  }     else                      { x0 = xlow;      y0 = Eval(xlow); }    if      (xhig<=GetX(i))   { x1 = GetX(i);   y1 = GetY(i);    }    else if (xhig>=GetX(i+1)) { x1 = GetX(i+1); y1 = GetY(i+1);  }    else                      { x1 = xhig;      y1 = Eval(xhig); }    sum  += (y1+y0)*(x1-x0)/2.;  }  return sum;}

void CParametricSurface::Vertex(Vec2 domain){    Vec3 p0, p1, p2, p3;    Vec3 normal;    float u = domain.x;    float v = domain.y;	    Eval(domain, p0);    Vec2 z1(u + du/2, v);    Eval(z1, p1);    Vec2 z2(u + du/2 + du, v);    Eval(z2, p3);	    if (flipped) {        Vec2 z3(u + du/2, v - dv);        Eval(z3, p2);    } else {        Vec2 z4(u + du/2, v + dv);        Eval(z4, p2);    }	    const float epsilon = 0.00001f;	    Vec3 tangent = p3 - p1;    Vec3 binormal = p2 - p1;    MatrixVec3CrossProduct(normal, tangent, binormal);    if (normal.length() < epsilon)        normal = p0;    normal.normalize();	if (tangent.length() < epsilon)		MatrixVec3CrossProduct(tangent, binormal, normal);	tangent.normalize();	binormal.normalize();	binormal = binormal * -1.0f;	 	/*    if (CustomAttributeLocation() != -1)        glVertexAttrib1f(CustomAttributeLocation(), CustomAttributeValue(domain));	 */	    //glNormal(normal);    //glTexCoord(domain);    //glVertex(p0);	int vertexIndex = totalVertex * 14;	vertexBuffer[vertexIndex++] = p0.x;	vertexBuffer[vertexIndex++] = p0.y;	vertexBuffer[vertexIndex++] = p0.z;	vertexBuffer[vertexIndex++] = domain.x;	vertexBuffer[vertexIndex++] = domain.y;	vertexBuffer[vertexIndex++] = normal.x;	vertexBuffer[vertexIndex++] = normal.y;	vertexBuffer[vertexIndex++] = normal.z;	vertexBuffer[vertexIndex++] = tangent.x;	vertexBuffer[vertexIndex++] = tangent.y;	vertexBuffer[vertexIndex++] = tangent.z;	vertexBuffer[vertexIndex++] = binormal.x;	vertexBuffer[vertexIndex++] = binormal.y;	vertexBuffer[vertexIndex++] = binormal.z;}

int scope_run(SuperScopePrivate *priv, ScopeRunnable runnable){    RESULT result;    SetVariableNumeric("n", priv->n);    SetVariableNumeric("b", priv->b);    SetVariableNumeric("x", priv->x);    SetVariableNumeric("y", priv->y);    SetVariableNumeric("i", priv->i);    SetVariableNumeric("v", priv->v);    SetVariableNumeric("w", priv->w);    SetVariableNumeric("h", priv->h);    SetVariableNumeric("red", priv->red);    SetVariableNumeric("green", priv->green);    SetVariableNumeric("blue", priv->blue);    SetVariableNumeric("linesize", priv->linesize);    SetVariableNumeric("skip", priv->skip);    SetVariableNumeric("drawmode", priv->drawmode);    SetVariableNumeric("t", priv->t);    SetVariableNumeric("d", priv->d);    switch(runnable) {        case SCOPE_RUNNABLE_INIT:		Eval(priv->init, &result);	break;	case SCOPE_RUNNABLE_BEAT:		Eval(priv->beat, &result);	break;	case SCOPE_RUNNABLE_FRAME:		Eval(priv->frame, &result);	break;	case SCOPE_RUNNABLE_POINT:		Eval(priv->point, &result);	break;    }    //(FindVariable("n"))->value = NULL;    VARIABLE var;    var.value = NULL;    priv->n = R2N(FindVariable("n")->value);    priv->b = R2N(FindVariable("b")->value);    priv->x = R2N(FindVariable("x")->value);    priv->y = R2N(FindVariable("y")->value);    priv->i = R2N(FindVariable("i")->value);    priv->v = R2N(FindVariable("v")->value);    priv->w = R2N(FindVariable("w")->value);    priv->h = R2N(FindVariable("h")->value);    priv->red = R2N(FindVariable("red")->value);    priv->green = R2N(FindVariable("green")->value);    priv->blue = R2N(FindVariable("blue")->value);    priv->linesize = R2N(FindVariable("linesize")->value);    priv->skip = R2N(FindVariable("skip")->value);    priv->drawmode = R2N(FindVariable("drawmode")->value);    priv->t = R2N(FindVariable("t")->value);    priv->d = R2N(FindVariable("d")->value);    return 0;}

sint32 SlicFrame::IsEqual(SS_TYPE type1, SlicStackValue value1,						  SS_TYPE type2, SlicStackValue value2){	SlicSymbolData *sym1, *sym2;	if(type1 == SS_TYPE_INT || type2 == SS_TYPE_INT) {		return Eval(type1, value1) == Eval(type2, value2);	}	switch(type1) {		case SS_TYPE_SYM:		case SS_TYPE_VAR:		{			if(type1 == SS_TYPE_SYM) {				sym1 = value1.m_sym;			} else {				sym1 = g_slicEngine->GetSymbol(value1.m_int);			}			if(type2 == SS_TYPE_SYM) {				sym2 = value2.m_sym;			} else if(type2 == SS_TYPE_VAR) {				sym2 = g_slicEngine->GetSymbol(value2.m_int);			} else {				Assert(FALSE);				return 0;			}			MapPoint pos1, pos2;			Unit u1, u2;			if(sym1->GetPos(pos1)) {				if(sym2->GetPos(pos2)) {					return pos1 == pos2;				}			} 			if(sym1->GetUnit(u1)) {				if(sym2->GetUnit(u2)) {					return u1 == u2;				}			} 			if(sym1->GetCity(u1)) {				if(sym2->GetCity(u2)) {					return u1 == u2;				}			}						if(sym1->GetType() != SLIC_SYM_IVAR)				return 0;			if(sym2->GetType() != SLIC_SYM_IVAR)				return 0;			return Eval(type1, value1) == Eval(type2, value2);		}		default:			Assert(FALSE);			return 0;	}}

var EvalEx(Var expression){	var head = Eval(Head(expression));	var body;	var result;	if(SymQ(head))	{		std::map<Var,attr_t>::const_iterator			iter = Attributes.find(head);		if(iter != Attributes.end())		{			if (HandleAttributes(result, expression, iter->second, head, body))			{				return result;			}		}		else		{			body = Eval(Body(expression));		}		if (SearchFactValues(result, head, body))		{			return result;		}		if (SearchDownValues(result, head, body))		{			return result;		}		if (SearchCProcs(result, head, body))		{			return result;		}	}	else	{		body = Eval(Body(expression));		if(ExQ(head) && SymQ(Head(head)))		{			if (SearchSubValues(result, head, body))			{				return result;			}			if (SearchCOpers(result, head, body))			{				return result;			}		}	}	return Ex(head,body);}

bool CAG_RegEx::CreateNFA(string strRegEx){	// Parse regular expresion using similar 	// method to evaluate arithmetic expressions	// But first we will detect concatenation and	// insert char(8) at the position where 	// concatenation needs to occur	strRegEx = ConcatExpand(strRegEx);	cout<<strRegEx<<" : length "<<strRegEx.size()<<endl;	for(int i=0; i<strRegEx.size(); ++i)	{		// get the charcter		char c = strRegEx[i];				if(IsInput(c))			Push(c);		else if(m_OperatorStack.empty())			m_OperatorStack.push(c);		else if(IsLeftParanthesis(c))			m_OperatorStack.push(c);		else if(IsRightParanthesis(c))		{			// Evaluate everyting in paranthesis			while(!IsLeftParanthesis(m_OperatorStack.top()))				if(!Eval())					return false;			// Remove left paranthesis after the evaluation			m_OperatorStack.pop(); 		}		else		{			while(!m_OperatorStack.empty() && Presedence(c, m_OperatorStack.top()))				if(!Eval())					return false;			m_OperatorStack.push(c);		}	}	// Evaluate the rest of operators	while(!m_OperatorStack.empty())		if(!Eval())			return false;	// Pop the result from the stack	if(!Pop(m_NFATable))		return false;	// Last NFA state is always accepting state	m_NFATable[m_NFATable.size()-1]->m_bAcceptingState = true;	return true;}

double EvalProbL(int j,int x,int layers)  {	int i=0;	DModel *m= (DModel*)&(models[j]);	double error=0;	double y=0;	int length=m->len;	if  (m->len < x) {//	elog(WARNING," Future %d %d",x,m->len);}//	double y= Eval(j,x,&error);// no need to compute the value	//elog(WARNING, "Model error%f requested error %f",error,err);	//btw, compute the next values and add them to the cache	//	return y;	if ((layers==0)||(m->nc <= 0)) {		//elog(WARNING," matches the error %p",cache);		if((cache != NULL) && (m_cache>0)) {			//    elog(WARNING, "Filling from %d len: %d",x+1+i,m_cache);	       			cache_start=x+1;			for(i=0;i<m->len;i++) {			   if(i>=m_cache)break;			   cache[i]=Eval(j,x+1+i,&error);			 }			 for(i=x+m->len;i<m_cache;i++) {			    cache[i]=-1;			 }		}		y= Eval(j,x,&error);	//	elog(WARNING,"EvalProbL layers:%d val %lf",layers,y);	return y; // found result within the error	}	//elog(WARNING,"here");	DModel *mm;	int l=0;	l=m->children[0];	mm= (DModel*)&(models[l]);        int llen = mm->len;        int li = x / llen;	        if (li >= m->nc) {          li =m-> nc - 1;	  l=m->children[li];	  mm= (DModel*)&(models[l]);          llen = mm->len;            }	l=m->children[li];//	printf("l %d li %d/n",l,li);        double yy= EvalProbL(l,x % llen, layers-1);//	elog(WARNING, "Eval Prop L layers %d %lf",layers,yy);	return yy;}

Expr* EvalCons(Env* env, Expr* expr, Expr* cont){  Expr* arg1_expr = expr->next;  Expr* arg2_expr = expr->next->next;  Expr* arg1 = Eval(env, arg1_expr, cont);  Expr* arg2 = Eval(env, arg2_expr, cont);  Expr* ret = malloc(sizeof(Expr));  ret->type = Pair_Exp;  ret->u.list = arg1;  //  arg1->next = NullList();  //  ar->next  = arg2;  ret->next = arg2;  return ret;}

Expr* EvalMul(Env* env, Expr* expr, Expr* cont){  int x ,y;   Expr *x_expr, *y_expr;  x_expr = Eval(env, GetSecond(expr), cont);  x = x_expr->u.int_value;  y_expr = Eval(env, GetThird(expr), cont);  y = y_expr->u.int_value;  printf("%d/n", x * y);  Expr *ret_val = malloc(sizeof(Expr));  ret_val->type = Number_Exp;  ret_val->u.int_value = x * y;  return ret_val;}

// Send out a normal, texture coordinate, vertex coordinate, and an optional custom attribute.void TParametricSurface::Vertex(vec2 domain){    vec3 p0, p1, p2, p3;    vec3 normal;    float u = domain.u;    float v = domain.v;    Eval(domain, p0);    vec2 z1(u + du/2, v);    Eval(z1, p1);    vec2 z2(u + du/2 + du, v);    Eval(z2, p3);    if (flipped) {        vec2 z3(u + du/2, v - dv);        Eval(z3, p2);    } else {        vec2 z4(u + du/2, v + dv);        Eval(z4, p2);    }    const float epsilon = 0.00001f;    vec3 tangent = p3 - p1;    vec3 binormal = p2 - p1;    normal = cross(tangent, binormal);    if (normal.magnitude() < epsilon)        normal = p0;    normal.unitize();    if (tangentLoc != -1)    {        if (tangent.magnitude() < epsilon)            tangent = cross(binormal, normal);        tangent.unitize();        glVertexAttrib(tangentLoc, tangent);    }    if (binormalLoc != -1)    {        binormal.unitize();        glVertexAttrib(binormalLoc, -binormal);    }    if (CustomAttributeLocation() != -1)        glVertexAttrib1f(CustomAttributeLocation(), CustomAttributeValue(domain));    glNormal(normal);    glTexCoord(domain);    glVertex(p0);}

// the quiescence searchint Quiece(board_t *brd, int alpha, int beta, searchinfo_t *sinfo){	if(!(sinfo->nodes & 0xfff)) CheckUp(sinfo);	sinfo->nodes++;	ASSERT(CheckBrd(brd));	//if((IsRep(brd) || brd->fifty >= 100) && brd->ply) return 0;	if(brd->ply >= MAXDEPTH-1) return Eval(brd);	int score = Eval(brd);	// we are probably not going to make our position worse by moving so we can say:	if(score >= beta){	// if we are doing already too good		return beta;	// we have a beta cutoff and we return	}	if(score > alpha){	// if we are better than alpha		alpha = score;	// then we can set our minimum alpha to the score	}	mlist_t list;	int i;	score = -INFINITE;	GenCaps(brd, &list);	// Generate all capture moves	for(i = 0; i < list.len; i++)	// Loop through the moves	{		if(sinfo->stop) return 0;		SelectNextMove(&list, i);		if(!MakeMove(brd, list.move[i].move)) continue;		score = -Quiece(brd, -beta, -alpha, sinfo);		TakeBack(brd);		if(score > alpha){			if(score >= beta){				return beta;			}			alpha = score;		}	}	return alpha;}

bool HandleAttributes(var &result, Var expression, const attr_t &attributes,						var head, var &body){	if(attributes.count(SequenceHold))	{		body = Body(expression);	}	else	{		body = FlattenSequence(Body(expression), false);	}	size_t n = Size(body);	// FIXME: in mathematica, OneIdentity means "x == f[x]" only for PATTERN MATCHING purposes// 	if(n == 1 && attributes.count(OneIdentity))// 	{// 		result = Eval(At(body,0));// 		return true;// 	}	if(!attributes.count(HoldAll))	{		if(n > 0 && !attributes.count(HoldFirst))			At(body,0) = Eval(At(body,0));		if(n > 1 && !attributes.count(HoldRest))			for(size_t i = 1; i < n; ++i)				At(body,i) = Eval(At(body,i));	}	if(attributes.count(Listable))	{		// TODO: handle the case where all list must be of same length, e.g. CoprimeQ		var t = Thread(head,body);		if(t)		{			result = Eval(t);			return true;		}	}	if(attributes.count(Flat))	{		var t = body;		body = Vec();		Reserve(body,n);		Flatten(body,head,t);	}	if(attributes.count(Orderless))		Sort(body);	return false;}

bool CRay::IntersectSphere( const TVec &roPos, float fRadius ){	const TVec oVecV( m_oPos - roPos );	const float fVh2 = oVecV.Dot( oVecV );		// Mitternacht.	const float fA = m_oDir.Dot( m_oDir );	const float fB = 2.0f * oVecV.Dot( m_oDir );	const float fC = fVh2 - fRadius * fRadius;		const float fDet = ( fB * fB ) - ( 4.0f * fA * fC );		if( fDet >= 0.0f )	{		const float f1dA2 = 1.0f / ( 2.0f * fA );		const float fDetTerm = (float)sqrt( (double)fDet );		const float fT0 = ( -fB + fDetTerm ) * f1dA2;		const float fT1 = ( -fB - fDetTerm ) * f1dA2;				float fT = MAX( fT0, fT1 );		if( fT < 0.0f ) // Der Strahl ist eine Halbgerade!			return false;		m_oHit = Eval( fT );		TVec oNormal = ( m_oHit - m_oPos ).Normalized();		// Nur wenn Strahl mit der nach aussen gerichteten 		// Normalen max. einen Winkel von 90° bildet.		if( oNormal.Dot( m_oDir ) >= 0.0f ) 			return true;	}	return false;}

void ExprCopy::visit(const ExprApply& e) {	for (int i=0; i<e.nb_args; i++)		visit(e.arg(i));	if (fold) {		int i=0;		for (; i<e.nb_args; i++) {			if (!dynamic_cast<const ExprConstant*>(&ARG(i))) break;		}		if (i==e.nb_args) {			Array<const Domain> d(e.nb_args);			for (i=0; i<e.nb_args; i++) {				d.set_ref(i,((const ExprConstant&) ARG(i)).get());			}			clone.insert(e, &ExprConstant::new_(Eval().eval(e.func,d)));			return;		}	}	Array<const ExprNode> args2(e.nb_args);	for (int i=0; i<e.nb_args; i++) {		args2.set_ref(i,ARG(i));		// don't remove this node even if it is a constant because		// it is an argument of this function call.		mark(e.arg(i));	}	clone.insert(e, &ExprApply::new_(e.func, args2));}

int CSearch::Aspiration_Search(uint64_t P, uint64_t O, uint64_t& NodeCounter, int alpha, int beta, int score, int selectivity, int depth, int empties, CLine& PV_line){	int width = (depth == empties ? 2 : 1);	int down = width;	int up = width;	while (true)	{		int low = MAX(alpha, score - down);		int high = MIN(beta, score + up);		score = Eval(P, O, NodeCounter, low, high, selectivity, depth, empties, &PV_line);		print_stats(depth, selectivity);		if (score <= low && score > alpha && down > 0) // fail low		{			down *= 2;			up = 0;		}		else if (score >= high && score < beta && up > 0) // fail high		{			down = 0;			up *= 2;		}		else			break;	}	return score;}

DoSetWandState(SimView *view, short state){  char buf[256];  sprintf(buf, "UISetToolState %s %d", Tk_PathName(view->tkwin), state);  Eval(buf);}

/* Search game tree by alpha-beta algorith */short AlphaBeta(short alpha, short beta, short depth){    short i, value, best;    if (!depth) return Eval();    Gen();    best = -INFINITY;    for (i=gen_begin[ply]; i<gen_end[ply] && best<beta; i++)    {        if (best > alpha) alpha = best;        if (MakeMove(gen_dat[i].m)) value = 1000-ply;        else value = -AlphaBeta(-beta, -alpha, depth-1);        UnMakeMove();        if (value > best)        {            best = value; if (!ply) newmove = gen_dat[i].m;        }    }    return best;}

std::string StreamBuffString(Value* eos, EnvironmentFrame* env) {    OStream*            os  = assert_type<OStream>(Eval(eos, env));    std::ostringstream* oss = dynamic_cast<std::ostringstream*>(os->value());    if (!oss) throw std::runtime_error("Expected a stream buffer to read.");    return oss->str();}

BOOL MorphObject::PolygonCount(TimeValue t, int& faceCount, int& vertCount)   {   ObjectState os = Eval(t);   Object *obj = os.obj;   if (!obj) return FALSE;   return obj->PolygonCount(t, faceCount, vertCount);   }

/// @memberof isnan/1static Intp_isinf( USES_REGS1 ){                               /* X is Y        */  Term out = 0L;  while (!(out = Eval(Deref(ARG1) PASS_REGS))) {    if (LOCAL_Error_TYPE == RESOURCE_ERROR_STACK) {      LOCAL_Error_TYPE = YAP_NO_ERROR;      if (!Yap_gcl(LOCAL_Error_Size, 1, ENV, CP)) {        Yap_EvalError(RESOURCE_ERROR_STACK, ARG2, LOCAL_ErrorMessage);        return FALSE;      }    } else {      Yap_EvalError(LOCAL_Error_TYPE, LOCAL_Error_Term, LOCAL_ErrorMessage);      return FALSE;    }  }  if (IsVarTerm(out)) {    Yap_EvalError(INSTANTIATION_ERROR, out, "isinf/1");    return FALSE;  }  if (!IsFloatTerm(out)) {    Yap_EvalError(TYPE_ERROR_FLOAT, out, "isinf/1");    return FALSE;  }  return isinf(FloatOfTerm(out));}

/// @memberof between/3static Int cont_between( USES_REGS1 ){  Term t1 = EXTRA_CBACK_ARG(3,1);  Term t2 = EXTRA_CBACK_ARG(3,2);    Yap_unify(ARG3, t1);  if (IsIntegerTerm(t1)) {    Int i1;    Term tn;    if (t1 == t2)      cut_succeed();    i1 = IntegerOfTerm(t1);    tn = add_int(i1, 1 PASS_REGS);    EXTRA_CBACK_ARG(3,1) = tn;    HB = B->cp_h = HR;    return TRUE;  } else {    Term t[2];    Term tn;    Int cmp;    cmp = Yap_acmp(t1, t2 PASS_REGS);    if (cmp == 0)      cut_succeed();    t[0] = t1;    t[1] = MkIntTerm(1);    tn = Eval(Yap_MkApplTerm(FunctorPlus, 2, t) PASS_REGS);    EXTRA_CBACK_ARG(3,1) = tn;    HB = B->cp_h = HR;    return TRUE;  }}