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 search int 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/1 static Int p_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/3 static 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; } }
Object* MorphObject::ConvertToType(TimeValue t, Class_ID obtype) { ObjectState os = Eval(t); Object *obj = os.obj->ConvertToType(t,obtype); if (!obj) return NULL; return (Object*)CloneRefHierarchy(obj); }